mly.c revision 1.42
1 /* $NetBSD: mly.c,v 1.42 2009/05/12 08:23:01 cegger Exp $ */ 2 3 /*- 4 * Copyright (c) 2001 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Doran, Thor Lancelot Simon, and Eric Haszlakiewicz. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /*- 33 * Copyright (c) 2000, 2001 Michael Smith 34 * Copyright (c) 2000 BSDi 35 * All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 46 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 47 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 49 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 50 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 51 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 52 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 53 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 54 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 55 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 56 * SUCH DAMAGE. 57 * 58 * from FreeBSD: mly.c,v 1.8 2001/07/14 00:12:22 msmith Exp 59 */ 60 61 /* 62 * Driver for the Mylex AcceleRAID and eXtremeRAID family with v6 firmware. 63 * 64 * TODO: 65 * 66 * o Make mly->mly_btl a hash, then MLY_BTL_RESCAN becomes a SIMPLEQ. 67 * o Handle FC and multiple LUNs. 68 * o Fix mmbox usage. 69 * o Fix transfer speed fudge. 70 */ 71 72 #include <sys/cdefs.h> 73 __KERNEL_RCSID(0, "$NetBSD: mly.c,v 1.42 2009/05/12 08:23:01 cegger Exp $"); 74 75 #include <sys/param.h> 76 #include <sys/systm.h> 77 #include <sys/device.h> 78 #include <sys/kernel.h> 79 #include <sys/queue.h> 80 #include <sys/buf.h> 81 #include <sys/endian.h> 82 #include <sys/conf.h> 83 #include <sys/malloc.h> 84 #include <sys/ioctl.h> 85 #include <sys/scsiio.h> 86 #include <sys/kthread.h> 87 #include <sys/kauth.h> 88 89 #include <uvm/uvm_extern.h> 90 91 #include <sys/bus.h> 92 93 #include <dev/scsipi/scsi_all.h> 94 #include <dev/scsipi/scsipi_all.h> 95 #include <dev/scsipi/scsiconf.h> 96 97 #include <dev/pci/pcireg.h> 98 #include <dev/pci/pcivar.h> 99 #include <dev/pci/pcidevs.h> 100 101 #include <dev/pci/mlyreg.h> 102 #include <dev/pci/mlyio.h> 103 #include <dev/pci/mlyvar.h> 104 #include <dev/pci/mly_tables.h> 105 106 static void mly_attach(device_t, device_t, void *); 107 static int mly_match(device_t, cfdata_t, void *); 108 static const struct mly_ident *mly_find_ident(struct pci_attach_args *); 109 static int mly_fwhandshake(struct mly_softc *); 110 static int mly_flush(struct mly_softc *); 111 static int mly_intr(void *); 112 static void mly_shutdown(void *); 113 114 static int mly_alloc_ccbs(struct mly_softc *); 115 static void mly_check_event(struct mly_softc *); 116 static void mly_complete_event(struct mly_softc *, struct mly_ccb *); 117 static void mly_complete_rescan(struct mly_softc *, struct mly_ccb *); 118 static int mly_dmamem_alloc(struct mly_softc *, int, bus_dmamap_t *, 119 void **, bus_addr_t *, bus_dma_segment_t *); 120 static void mly_dmamem_free(struct mly_softc *, int, bus_dmamap_t, 121 void *, bus_dma_segment_t *); 122 static int mly_enable_mmbox(struct mly_softc *); 123 static void mly_fetch_event(struct mly_softc *); 124 static int mly_get_controllerinfo(struct mly_softc *); 125 static int mly_get_eventstatus(struct mly_softc *); 126 static int mly_ioctl(struct mly_softc *, struct mly_cmd_ioctl *, 127 void **, size_t, void *, size_t *); 128 static void mly_padstr(char *, const char *, int); 129 static void mly_process_event(struct mly_softc *, struct mly_event *); 130 static void mly_release_ccbs(struct mly_softc *); 131 static int mly_scan_btl(struct mly_softc *, int, int); 132 static void mly_scan_channel(struct mly_softc *, int); 133 static void mly_thread(void *); 134 135 static int mly_ccb_alloc(struct mly_softc *, struct mly_ccb **); 136 static void mly_ccb_complete(struct mly_softc *, struct mly_ccb *); 137 static void mly_ccb_enqueue(struct mly_softc *, struct mly_ccb *); 138 static void mly_ccb_free(struct mly_softc *, struct mly_ccb *); 139 static int mly_ccb_map(struct mly_softc *, struct mly_ccb *); 140 static int mly_ccb_poll(struct mly_softc *, struct mly_ccb *, int); 141 static int mly_ccb_submit(struct mly_softc *, struct mly_ccb *); 142 static void mly_ccb_unmap(struct mly_softc *, struct mly_ccb *); 143 static int mly_ccb_wait(struct mly_softc *, struct mly_ccb *, int); 144 145 static void mly_get_xfer_mode(struct mly_softc *, int, 146 struct scsipi_xfer_mode *); 147 static void mly_scsipi_complete(struct mly_softc *, struct mly_ccb *); 148 static int mly_scsipi_ioctl(struct scsipi_channel *, u_long, void *, 149 int, struct proc *); 150 static void mly_scsipi_minphys(struct buf *); 151 static void mly_scsipi_request(struct scsipi_channel *, 152 scsipi_adapter_req_t, void *); 153 154 static int mly_user_command(struct mly_softc *, struct mly_user_command *); 155 static int mly_user_health(struct mly_softc *, struct mly_user_health *); 156 157 extern struct cfdriver mly_cd; 158 159 CFATTACH_DECL(mly, sizeof(struct mly_softc), 160 mly_match, mly_attach, NULL, NULL); 161 162 dev_type_open(mlyopen); 163 dev_type_close(mlyclose); 164 dev_type_ioctl(mlyioctl); 165 166 const struct cdevsw mly_cdevsw = { 167 mlyopen, mlyclose, noread, nowrite, mlyioctl, 168 nostop, notty, nopoll, nommap, nokqfilter, D_OTHER, 169 }; 170 171 static struct mly_ident { 172 u_short vendor; 173 u_short product; 174 u_short subvendor; 175 u_short subproduct; 176 int hwif; 177 const char *desc; 178 } const mly_ident[] = { 179 { 180 PCI_VENDOR_MYLEX, 181 PCI_PRODUCT_MYLEX_EXTREMERAID, 182 PCI_VENDOR_MYLEX, 183 0x0040, 184 MLY_HWIF_STRONGARM, 185 "eXtremeRAID 2000" 186 }, 187 { 188 PCI_VENDOR_MYLEX, 189 PCI_PRODUCT_MYLEX_EXTREMERAID, 190 PCI_VENDOR_MYLEX, 191 0x0030, 192 MLY_HWIF_STRONGARM, 193 "eXtremeRAID 3000" 194 }, 195 { 196 PCI_VENDOR_MYLEX, 197 PCI_PRODUCT_MYLEX_ACCELERAID, 198 PCI_VENDOR_MYLEX, 199 0x0050, 200 MLY_HWIF_I960RX, 201 "AcceleRAID 352" 202 }, 203 { 204 PCI_VENDOR_MYLEX, 205 PCI_PRODUCT_MYLEX_ACCELERAID, 206 PCI_VENDOR_MYLEX, 207 0x0052, 208 MLY_HWIF_I960RX, 209 "AcceleRAID 170" 210 }, 211 { 212 PCI_VENDOR_MYLEX, 213 PCI_PRODUCT_MYLEX_ACCELERAID, 214 PCI_VENDOR_MYLEX, 215 0x0054, 216 MLY_HWIF_I960RX, 217 "AcceleRAID 160" 218 }, 219 }; 220 221 static void *mly_sdh; 222 223 /* 224 * Try to find a `mly_ident' entry corresponding to this board. 225 */ 226 static const struct mly_ident * 227 mly_find_ident(struct pci_attach_args *pa) 228 { 229 const struct mly_ident *mpi, *maxmpi; 230 pcireg_t reg; 231 232 mpi = mly_ident; 233 maxmpi = mpi + sizeof(mly_ident) / sizeof(mly_ident[0]); 234 235 if (PCI_CLASS(pa->pa_class) == PCI_CLASS_I2O) 236 return (NULL); 237 238 for (; mpi < maxmpi; mpi++) { 239 if (PCI_VENDOR(pa->pa_id) != mpi->vendor || 240 PCI_PRODUCT(pa->pa_id) != mpi->product) 241 continue; 242 243 if (mpi->subvendor == 0x0000) 244 return (mpi); 245 246 reg = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 247 248 if (PCI_VENDOR(reg) == mpi->subvendor && 249 PCI_PRODUCT(reg) == mpi->subproduct) 250 return (mpi); 251 } 252 253 return (NULL); 254 } 255 256 /* 257 * Match a supported board. 258 */ 259 static int 260 mly_match(device_t parent, cfdata_t cfdata, void *aux) 261 { 262 263 return (mly_find_ident(aux) != NULL); 264 } 265 266 /* 267 * Attach a supported board. 268 */ 269 static void 270 mly_attach(device_t parent, device_t self, void *aux) 271 { 272 struct pci_attach_args *pa; 273 struct mly_softc *mly; 274 struct mly_ioctl_getcontrollerinfo *mi; 275 const struct mly_ident *ident; 276 pci_chipset_tag_t pc; 277 pci_intr_handle_t ih; 278 bus_space_handle_t memh, ioh; 279 bus_space_tag_t memt, iot; 280 pcireg_t reg; 281 const char *intrstr; 282 int ior, memr, i, rv, state; 283 struct scsipi_adapter *adapt; 284 struct scsipi_channel *chan; 285 286 mly = device_private(self); 287 pa = aux; 288 pc = pa->pa_pc; 289 ident = mly_find_ident(pa); 290 state = 0; 291 292 mly->mly_dmat = pa->pa_dmat; 293 mly->mly_hwif = ident->hwif; 294 295 printf(": Mylex %s\n", ident->desc); 296 297 /* 298 * Map the PCI register window. 299 */ 300 memr = -1; 301 ior = -1; 302 303 for (i = 0x10; i <= 0x14; i += 4) { 304 reg = pci_conf_read(pa->pa_pc, pa->pa_tag, i); 305 306 if (PCI_MAPREG_TYPE(reg) == PCI_MAPREG_TYPE_IO) { 307 if (ior == -1 && PCI_MAPREG_IO_SIZE(reg) != 0) 308 ior = i; 309 } else { 310 if (memr == -1 && PCI_MAPREG_MEM_SIZE(reg) != 0) 311 memr = i; 312 } 313 } 314 315 if (memr != -1) 316 if (pci_mapreg_map(pa, memr, PCI_MAPREG_TYPE_MEM, 0, 317 &memt, &memh, NULL, NULL)) 318 memr = -1; 319 if (ior != -1) 320 if (pci_mapreg_map(pa, ior, PCI_MAPREG_TYPE_IO, 0, 321 &iot, &ioh, NULL, NULL)) 322 ior = -1; 323 324 if (memr != -1) { 325 mly->mly_iot = memt; 326 mly->mly_ioh = memh; 327 } else if (ior != -1) { 328 mly->mly_iot = iot; 329 mly->mly_ioh = ioh; 330 } else { 331 aprint_error_dev(self, "can't map i/o or memory space\n"); 332 return; 333 } 334 335 /* 336 * Enable the device. 337 */ 338 reg = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG); 339 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 340 reg | PCI_COMMAND_MASTER_ENABLE); 341 342 /* 343 * Map and establish the interrupt. 344 */ 345 if (pci_intr_map(pa, &ih)) { 346 aprint_error_dev(self, "can't map interrupt\n"); 347 return; 348 } 349 intrstr = pci_intr_string(pc, ih); 350 mly->mly_ih = pci_intr_establish(pc, ih, IPL_BIO, mly_intr, mly); 351 if (mly->mly_ih == NULL) { 352 aprint_error_dev(self, "can't establish interrupt"); 353 if (intrstr != NULL) 354 printf(" at %s", intrstr); 355 printf("\n"); 356 return; 357 } 358 359 if (intrstr != NULL) 360 printf("%s: interrupting at %s\n", device_xname(&mly->mly_dv), 361 intrstr); 362 363 /* 364 * Take care of interface-specific tasks. 365 */ 366 switch (mly->mly_hwif) { 367 case MLY_HWIF_I960RX: 368 mly->mly_doorbell_true = 0x00; 369 mly->mly_cmd_mailbox = MLY_I960RX_COMMAND_MAILBOX; 370 mly->mly_status_mailbox = MLY_I960RX_STATUS_MAILBOX; 371 mly->mly_idbr = MLY_I960RX_IDBR; 372 mly->mly_odbr = MLY_I960RX_ODBR; 373 mly->mly_error_status = MLY_I960RX_ERROR_STATUS; 374 mly->mly_interrupt_status = MLY_I960RX_INTERRUPT_STATUS; 375 mly->mly_interrupt_mask = MLY_I960RX_INTERRUPT_MASK; 376 break; 377 378 case MLY_HWIF_STRONGARM: 379 mly->mly_doorbell_true = 0xff; 380 mly->mly_cmd_mailbox = MLY_STRONGARM_COMMAND_MAILBOX; 381 mly->mly_status_mailbox = MLY_STRONGARM_STATUS_MAILBOX; 382 mly->mly_idbr = MLY_STRONGARM_IDBR; 383 mly->mly_odbr = MLY_STRONGARM_ODBR; 384 mly->mly_error_status = MLY_STRONGARM_ERROR_STATUS; 385 mly->mly_interrupt_status = MLY_STRONGARM_INTERRUPT_STATUS; 386 mly->mly_interrupt_mask = MLY_STRONGARM_INTERRUPT_MASK; 387 break; 388 } 389 390 /* 391 * Allocate and map the scatter/gather lists. 392 */ 393 rv = mly_dmamem_alloc(mly, MLY_SGL_SIZE * MLY_MAX_CCBS, 394 &mly->mly_sg_dmamap, (void **)&mly->mly_sg, 395 &mly->mly_sg_busaddr, &mly->mly_sg_seg); 396 if (rv) { 397 printf("%s: unable to allocate S/G maps\n", 398 device_xname(&mly->mly_dv)); 399 goto bad; 400 } 401 state++; 402 403 /* 404 * Allocate and map the memory mailbox. 405 */ 406 rv = mly_dmamem_alloc(mly, sizeof(struct mly_mmbox), 407 &mly->mly_mmbox_dmamap, (void **)&mly->mly_mmbox, 408 &mly->mly_mmbox_busaddr, &mly->mly_mmbox_seg); 409 if (rv) { 410 aprint_error_dev(&mly->mly_dv, "unable to allocate mailboxes\n"); 411 goto bad; 412 } 413 state++; 414 415 /* 416 * Initialise per-controller queues. 417 */ 418 SLIST_INIT(&mly->mly_ccb_free); 419 SIMPLEQ_INIT(&mly->mly_ccb_queue); 420 421 /* 422 * Disable interrupts before we start talking to the controller. 423 */ 424 mly_outb(mly, mly->mly_interrupt_mask, MLY_INTERRUPT_MASK_DISABLE); 425 426 /* 427 * Wait for the controller to come ready, handshaking with the 428 * firmware if required. This is typically only necessary on 429 * platforms where the controller BIOS does not run. 430 */ 431 if (mly_fwhandshake(mly)) { 432 aprint_error_dev(&mly->mly_dv, "unable to bring controller online\n"); 433 goto bad; 434 } 435 436 /* 437 * Allocate initial command buffers, obtain controller feature 438 * information, and then reallocate command buffers, since we'll 439 * know how many we want. 440 */ 441 if (mly_alloc_ccbs(mly)) { 442 aprint_error_dev(&mly->mly_dv, "unable to allocate CCBs\n"); 443 goto bad; 444 } 445 state++; 446 if (mly_get_controllerinfo(mly)) { 447 aprint_error_dev(&mly->mly_dv, "unable to retrieve controller info\n"); 448 goto bad; 449 } 450 mly_release_ccbs(mly); 451 if (mly_alloc_ccbs(mly)) { 452 aprint_error_dev(&mly->mly_dv, "unable to allocate CCBs\n"); 453 state--; 454 goto bad; 455 } 456 457 /* 458 * Get the current event counter for health purposes, populate the 459 * initial health status buffer. 460 */ 461 if (mly_get_eventstatus(mly)) { 462 aprint_error_dev(&mly->mly_dv, "unable to retrieve event status\n"); 463 goto bad; 464 } 465 466 /* 467 * Enable memory-mailbox mode. 468 */ 469 if (mly_enable_mmbox(mly)) { 470 aprint_error_dev(&mly->mly_dv, "unable to enable memory mailbox\n"); 471 goto bad; 472 } 473 474 /* 475 * Print a little information about the controller. 476 */ 477 mi = mly->mly_controllerinfo; 478 479 printf("%s: %d physical channel%s, firmware %d.%02d-%d-%02d " 480 "(%02d%02d%02d%02d), %dMB RAM\n", device_xname(&mly->mly_dv), 481 mi->physical_channels_present, 482 (mi->physical_channels_present) > 1 ? "s" : "", 483 mi->fw_major, mi->fw_minor, mi->fw_turn, mi->fw_build, 484 mi->fw_century, mi->fw_year, mi->fw_month, mi->fw_day, 485 le16toh(mi->memory_size)); 486 487 /* 488 * Register our `shutdownhook'. 489 */ 490 if (mly_sdh == NULL) 491 shutdownhook_establish(mly_shutdown, NULL); 492 493 /* 494 * Clear any previous BTL information. For each bus that scsipi 495 * wants to scan, we'll receive the SCBUSIOLLSCAN ioctl and retrieve 496 * all BTL info at that point. 497 */ 498 memset(&mly->mly_btl, 0, sizeof(mly->mly_btl)); 499 500 mly->mly_nchans = mly->mly_controllerinfo->physical_channels_present + 501 mly->mly_controllerinfo->virtual_channels_present; 502 503 /* 504 * Attach to scsipi. 505 */ 506 adapt = &mly->mly_adapt; 507 memset(adapt, 0, sizeof(*adapt)); 508 adapt->adapt_dev = &mly->mly_dv; 509 adapt->adapt_nchannels = mly->mly_nchans; 510 adapt->adapt_openings = mly->mly_ncmds - MLY_CCBS_RESV; 511 adapt->adapt_max_periph = mly->mly_ncmds - MLY_CCBS_RESV; 512 adapt->adapt_request = mly_scsipi_request; 513 adapt->adapt_minphys = mly_scsipi_minphys; 514 adapt->adapt_ioctl = mly_scsipi_ioctl; 515 516 for (i = 0; i < mly->mly_nchans; i++) { 517 chan = &mly->mly_chans[i]; 518 memset(chan, 0, sizeof(*chan)); 519 chan->chan_adapter = adapt; 520 chan->chan_bustype = &scsi_bustype; 521 chan->chan_channel = i; 522 chan->chan_ntargets = MLY_MAX_TARGETS; 523 chan->chan_nluns = MLY_MAX_LUNS; 524 chan->chan_id = mly->mly_controllerparam->initiator_id; 525 chan->chan_flags = SCSIPI_CHAN_NOSETTLE; 526 config_found(&mly->mly_dv, chan, scsiprint); 527 } 528 529 /* 530 * Now enable interrupts... 531 */ 532 mly_outb(mly, mly->mly_interrupt_mask, MLY_INTERRUPT_MASK_ENABLE); 533 534 /* 535 * Finally, create our monitoring thread. 536 */ 537 mly->mly_state |= MLY_STATE_INITOK; 538 rv = kthread_create(PRI_NONE, 0, NULL, mly_thread, mly, 539 &mly->mly_thread, "%s", device_xname(&mly->mly_dv)); 540 if (rv != 0) 541 aprint_error_dev(&mly->mly_dv, "unable to create thread (%d)\n", 542 rv); 543 return; 544 545 bad: 546 if (state > 2) 547 mly_release_ccbs(mly); 548 if (state > 1) 549 mly_dmamem_free(mly, sizeof(struct mly_mmbox), 550 mly->mly_mmbox_dmamap, (void *)mly->mly_mmbox, 551 &mly->mly_mmbox_seg); 552 if (state > 0) 553 mly_dmamem_free(mly, MLY_SGL_SIZE * MLY_MAX_CCBS, 554 mly->mly_sg_dmamap, (void *)mly->mly_sg, 555 &mly->mly_sg_seg); 556 } 557 558 /* 559 * Scan all possible devices on the specified channel. 560 */ 561 static void 562 mly_scan_channel(struct mly_softc *mly, int bus) 563 { 564 int s, target; 565 566 for (target = 0; target < MLY_MAX_TARGETS; target++) { 567 s = splbio(); 568 if (!mly_scan_btl(mly, bus, target)) { 569 tsleep(&mly->mly_btl[bus][target], PRIBIO, "mlyscan", 570 0); 571 } 572 splx(s); 573 } 574 } 575 576 /* 577 * Shut down all configured `mly' devices. 578 */ 579 static void 580 mly_shutdown(void *cookie) 581 { 582 struct mly_softc *mly; 583 int i; 584 585 for (i = 0; i < mly_cd.cd_ndevs; i++) { 586 if ((mly = device_lookup_private(&mly_cd, i)) == NULL) 587 continue; 588 589 if (mly_flush(mly)) 590 aprint_error_dev(&mly->mly_dv, "unable to flush cache\n"); 591 } 592 } 593 594 /* 595 * Fill in the mly_controllerinfo and mly_controllerparam fields in the 596 * softc. 597 */ 598 static int 599 mly_get_controllerinfo(struct mly_softc *mly) 600 { 601 struct mly_cmd_ioctl mci; 602 int rv; 603 604 /* 605 * Build the getcontrollerinfo ioctl and send it. 606 */ 607 memset(&mci, 0, sizeof(mci)); 608 mci.sub_ioctl = MDACIOCTL_GETCONTROLLERINFO; 609 rv = mly_ioctl(mly, &mci, (void **)&mly->mly_controllerinfo, 610 sizeof(*mly->mly_controllerinfo), NULL, NULL); 611 if (rv != 0) 612 return (rv); 613 614 /* 615 * Build the getcontrollerparameter ioctl and send it. 616 */ 617 memset(&mci, 0, sizeof(mci)); 618 mci.sub_ioctl = MDACIOCTL_GETCONTROLLERPARAMETER; 619 rv = mly_ioctl(mly, &mci, (void **)&mly->mly_controllerparam, 620 sizeof(*mly->mly_controllerparam), NULL, NULL); 621 622 return (rv); 623 } 624 625 /* 626 * Rescan a device, possibly as a consequence of getting an event which 627 * suggests that it may have changed. Must be called with interrupts 628 * blocked. 629 */ 630 static int 631 mly_scan_btl(struct mly_softc *mly, int bus, int target) 632 { 633 struct mly_ccb *mc; 634 struct mly_cmd_ioctl *mci; 635 int rv; 636 637 if (target == mly->mly_controllerparam->initiator_id) { 638 mly->mly_btl[bus][target].mb_flags = MLY_BTL_PROTECTED; 639 return (EIO); 640 } 641 642 /* Don't re-scan if a scan is already in progress. */ 643 if ((mly->mly_btl[bus][target].mb_flags & MLY_BTL_SCANNING) != 0) 644 return (EBUSY); 645 646 /* Get a command. */ 647 if ((rv = mly_ccb_alloc(mly, &mc)) != 0) 648 return (rv); 649 650 /* Set up the data buffer. */ 651 mc->mc_data = malloc(sizeof(union mly_devinfo), 652 M_DEVBUF, M_NOWAIT|M_ZERO); 653 654 mc->mc_flags |= MLY_CCB_DATAIN; 655 mc->mc_complete = mly_complete_rescan; 656 657 /* 658 * Build the ioctl. 659 */ 660 mci = (struct mly_cmd_ioctl *)&mc->mc_packet->ioctl; 661 mci->opcode = MDACMD_IOCTL; 662 mci->timeout = 30 | MLY_TIMEOUT_SECONDS; 663 memset(&mci->param, 0, sizeof(mci->param)); 664 665 if (MLY_BUS_IS_VIRTUAL(mly, bus)) { 666 mc->mc_length = sizeof(struct mly_ioctl_getlogdevinfovalid); 667 mci->data_size = htole32(mc->mc_length); 668 mci->sub_ioctl = MDACIOCTL_GETLOGDEVINFOVALID; 669 _lto3l(MLY_LOGADDR(0, MLY_LOGDEV_ID(mly, bus, target)), 670 mci->addr); 671 } else { 672 mc->mc_length = sizeof(struct mly_ioctl_getphysdevinfovalid); 673 mci->data_size = htole32(mc->mc_length); 674 mci->sub_ioctl = MDACIOCTL_GETPHYSDEVINFOVALID; 675 _lto3l(MLY_PHYADDR(0, bus, target, 0), mci->addr); 676 } 677 678 /* 679 * Dispatch the command. 680 */ 681 if ((rv = mly_ccb_map(mly, mc)) != 0) { 682 free(mc->mc_data, M_DEVBUF); 683 mly_ccb_free(mly, mc); 684 return(rv); 685 } 686 687 mly->mly_btl[bus][target].mb_flags |= MLY_BTL_SCANNING; 688 mly_ccb_enqueue(mly, mc); 689 return (0); 690 } 691 692 /* 693 * Handle the completion of a rescan operation. 694 */ 695 static void 696 mly_complete_rescan(struct mly_softc *mly, struct mly_ccb *mc) 697 { 698 struct mly_ioctl_getlogdevinfovalid *ldi; 699 struct mly_ioctl_getphysdevinfovalid *pdi; 700 struct mly_cmd_ioctl *mci; 701 struct mly_btl btl, *btlp; 702 struct scsipi_xfer_mode xm; 703 int bus, target, rescan; 704 u_int tmp; 705 706 mly_ccb_unmap(mly, mc); 707 708 /* 709 * Recover the bus and target from the command. We need these even 710 * in the case where we don't have a useful response. 711 */ 712 mci = (struct mly_cmd_ioctl *)&mc->mc_packet->ioctl; 713 tmp = _3ltol(mci->addr); 714 rescan = 0; 715 716 if (mci->sub_ioctl == MDACIOCTL_GETLOGDEVINFOVALID) { 717 bus = MLY_LOGDEV_BUS(mly, MLY_LOGADDR_DEV(tmp)); 718 target = MLY_LOGDEV_TARGET(mly, MLY_LOGADDR_DEV(tmp)); 719 } else { 720 bus = MLY_PHYADDR_CHANNEL(tmp); 721 target = MLY_PHYADDR_TARGET(tmp); 722 } 723 724 btlp = &mly->mly_btl[bus][target]; 725 726 /* The default result is 'no device'. */ 727 memset(&btl, 0, sizeof(btl)); 728 btl.mb_flags = MLY_BTL_PROTECTED; 729 730 /* If the rescan completed OK, we have possibly-new BTL data. */ 731 if (mc->mc_status != 0) 732 goto out; 733 734 if (mc->mc_length == sizeof(*ldi)) { 735 ldi = (struct mly_ioctl_getlogdevinfovalid *)mc->mc_data; 736 tmp = le32toh(ldi->logical_device_number); 737 738 if (MLY_LOGDEV_BUS(mly, tmp) != bus || 739 MLY_LOGDEV_TARGET(mly, tmp) != target) { 740 #ifdef MLYDEBUG 741 printf("%s: WARNING: BTL rescan (logical) for %d:%d " 742 "returned data for %d:%d instead\n", 743 device_xname(&mly->mly_dv), bus, target, 744 MLY_LOGDEV_BUS(mly, tmp), 745 MLY_LOGDEV_TARGET(mly, tmp)); 746 #endif 747 goto out; 748 } 749 750 btl.mb_flags = MLY_BTL_LOGICAL | MLY_BTL_TQING; 751 btl.mb_type = ldi->raid_level; 752 btl.mb_state = ldi->state; 753 } else if (mc->mc_length == sizeof(*pdi)) { 754 pdi = (struct mly_ioctl_getphysdevinfovalid *)mc->mc_data; 755 756 if (pdi->channel != bus || pdi->target != target) { 757 #ifdef MLYDEBUG 758 printf("%s: WARNING: BTL rescan (physical) for %d:%d " 759 " returned data for %d:%d instead\n", 760 device_xname(&mly->mly_dv), 761 bus, target, pdi->channel, pdi->target); 762 #endif 763 goto out; 764 } 765 766 btl.mb_flags = MLY_BTL_PHYSICAL; 767 btl.mb_type = MLY_DEVICE_TYPE_PHYSICAL; 768 btl.mb_state = pdi->state; 769 btl.mb_speed = pdi->speed; 770 btl.mb_width = pdi->width; 771 772 if (pdi->state != MLY_DEVICE_STATE_UNCONFIGURED) 773 btl.mb_flags |= MLY_BTL_PROTECTED; 774 if (pdi->command_tags != 0) 775 btl.mb_flags |= MLY_BTL_TQING; 776 } else { 777 printf("%s: BTL rescan result invalid\n", device_xname(&mly->mly_dv)); 778 goto out; 779 } 780 781 /* Decide whether we need to rescan the device. */ 782 if (btl.mb_flags != btlp->mb_flags || 783 btl.mb_speed != btlp->mb_speed || 784 btl.mb_width != btlp->mb_width) 785 rescan = 1; 786 787 out: 788 *btlp = btl; 789 790 if (rescan && (btl.mb_flags & MLY_BTL_PROTECTED) == 0) { 791 xm.xm_target = target; 792 mly_get_xfer_mode(mly, bus, &xm); 793 /* XXX SCSI mid-layer rescan goes here. */ 794 } 795 796 /* Wake anybody waiting on the device to be rescanned. */ 797 wakeup(btlp); 798 799 free(mc->mc_data, M_DEVBUF); 800 mly_ccb_free(mly, mc); 801 } 802 803 /* 804 * Get the current health status and set the 'next event' counter to suit. 805 */ 806 static int 807 mly_get_eventstatus(struct mly_softc *mly) 808 { 809 struct mly_cmd_ioctl mci; 810 struct mly_health_status *mh; 811 int rv; 812 813 /* Build the gethealthstatus ioctl and send it. */ 814 memset(&mci, 0, sizeof(mci)); 815 mh = NULL; 816 mci.sub_ioctl = MDACIOCTL_GETHEALTHSTATUS; 817 818 rv = mly_ioctl(mly, &mci, (void *)&mh, sizeof(*mh), NULL, NULL); 819 if (rv) 820 return (rv); 821 822 /* Get the event counter. */ 823 mly->mly_event_change = le32toh(mh->change_counter); 824 mly->mly_event_waiting = le32toh(mh->next_event); 825 mly->mly_event_counter = le32toh(mh->next_event); 826 827 /* Save the health status into the memory mailbox */ 828 memcpy(&mly->mly_mmbox->mmm_health.status, mh, sizeof(*mh)); 829 830 bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap, 831 offsetof(struct mly_mmbox, mmm_health), 832 sizeof(mly->mly_mmbox->mmm_health), 833 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD); 834 835 free(mh, M_DEVBUF); 836 return (0); 837 } 838 839 /* 840 * Enable memory mailbox mode. 841 */ 842 static int 843 mly_enable_mmbox(struct mly_softc *mly) 844 { 845 struct mly_cmd_ioctl mci; 846 u_int8_t *sp; 847 u_int64_t tmp; 848 int rv; 849 850 /* Build the ioctl and send it. */ 851 memset(&mci, 0, sizeof(mci)); 852 mci.sub_ioctl = MDACIOCTL_SETMEMORYMAILBOX; 853 854 /* Set buffer addresses. */ 855 tmp = mly->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_command); 856 mci.param.setmemorymailbox.command_mailbox_physaddr = htole64(tmp); 857 858 tmp = mly->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_status); 859 mci.param.setmemorymailbox.status_mailbox_physaddr = htole64(tmp); 860 861 tmp = mly->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_health); 862 mci.param.setmemorymailbox.health_buffer_physaddr = htole64(tmp); 863 864 /* Set buffer sizes - abuse of data_size field is revolting. */ 865 sp = (u_int8_t *)&mci.data_size; 866 sp[0] = (sizeof(union mly_cmd_packet) * MLY_MMBOX_COMMANDS) >> 10; 867 sp[1] = (sizeof(union mly_status_packet) * MLY_MMBOX_STATUS) >> 10; 868 mci.param.setmemorymailbox.health_buffer_size = 869 sizeof(union mly_health_region) >> 10; 870 871 rv = mly_ioctl(mly, &mci, NULL, 0, NULL, NULL); 872 if (rv) 873 return (rv); 874 875 mly->mly_state |= MLY_STATE_MMBOX_ACTIVE; 876 return (0); 877 } 878 879 /* 880 * Flush all pending I/O from the controller. 881 */ 882 static int 883 mly_flush(struct mly_softc *mly) 884 { 885 struct mly_cmd_ioctl mci; 886 887 /* Build the ioctl */ 888 memset(&mci, 0, sizeof(mci)); 889 mci.sub_ioctl = MDACIOCTL_FLUSHDEVICEDATA; 890 mci.param.deviceoperation.operation_device = 891 MLY_OPDEVICE_PHYSICAL_CONTROLLER; 892 893 /* Pass it off to the controller */ 894 return (mly_ioctl(mly, &mci, NULL, 0, NULL, NULL)); 895 } 896 897 /* 898 * Perform an ioctl command. 899 * 900 * If (data) is not NULL, the command requires data transfer to the 901 * controller. If (*data) is NULL the command requires data transfer from 902 * the controller, and we will allocate a buffer for it. 903 */ 904 static int 905 mly_ioctl(struct mly_softc *mly, struct mly_cmd_ioctl *ioctl, void **data, 906 size_t datasize, void *sense_buffer, 907 size_t *sense_length) 908 { 909 struct mly_ccb *mc; 910 struct mly_cmd_ioctl *mci; 911 u_int8_t status; 912 int rv; 913 914 mc = NULL; 915 if ((rv = mly_ccb_alloc(mly, &mc)) != 0) 916 goto bad; 917 918 /* 919 * Copy the ioctl structure, but save some important fields and then 920 * fixup. 921 */ 922 mci = &mc->mc_packet->ioctl; 923 ioctl->sense_buffer_address = htole64(mci->sense_buffer_address); 924 ioctl->maximum_sense_size = mci->maximum_sense_size; 925 *mci = *ioctl; 926 mci->opcode = MDACMD_IOCTL; 927 mci->timeout = 30 | MLY_TIMEOUT_SECONDS; 928 929 /* Handle the data buffer. */ 930 if (data != NULL) { 931 if (*data == NULL) { 932 /* Allocate data buffer */ 933 mc->mc_data = malloc(datasize, M_DEVBUF, M_NOWAIT); 934 mc->mc_flags |= MLY_CCB_DATAIN; 935 } else { 936 mc->mc_data = *data; 937 mc->mc_flags |= MLY_CCB_DATAOUT; 938 } 939 mc->mc_length = datasize; 940 mc->mc_packet->generic.data_size = htole32(datasize); 941 } 942 943 /* Run the command. */ 944 if (datasize > 0) 945 if ((rv = mly_ccb_map(mly, mc)) != 0) 946 goto bad; 947 rv = mly_ccb_poll(mly, mc, 30000); 948 if (datasize > 0) 949 mly_ccb_unmap(mly, mc); 950 if (rv != 0) 951 goto bad; 952 953 /* Clean up and return any data. */ 954 status = mc->mc_status; 955 956 if (status != 0) 957 printf("mly_ioctl: command status %d\n", status); 958 959 if (mc->mc_sense > 0 && sense_buffer != NULL) { 960 memcpy(sense_buffer, mc->mc_packet, mc->mc_sense); 961 *sense_length = mc->mc_sense; 962 goto bad; 963 } 964 965 /* Should we return a data pointer? */ 966 if (data != NULL && *data == NULL) 967 *data = mc->mc_data; 968 969 /* Command completed OK. */ 970 rv = (status != 0 ? EIO : 0); 971 972 bad: 973 if (mc != NULL) { 974 /* Do we need to free a data buffer we allocated? */ 975 if (rv != 0 && mc->mc_data != NULL && 976 (data == NULL || *data == NULL)) 977 free(mc->mc_data, M_DEVBUF); 978 mly_ccb_free(mly, mc); 979 } 980 981 return (rv); 982 } 983 984 /* 985 * Check for event(s) outstanding in the controller. 986 */ 987 static void 988 mly_check_event(struct mly_softc *mly) 989 { 990 991 bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap, 992 offsetof(struct mly_mmbox, mmm_health), 993 sizeof(mly->mly_mmbox->mmm_health), 994 BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD); 995 996 /* 997 * The controller may have updated the health status information, so 998 * check for it here. Note that the counters are all in host 999 * memory, so this check is very cheap. Also note that we depend on 1000 * checking on completion 1001 */ 1002 if (le32toh(mly->mly_mmbox->mmm_health.status.change_counter) != 1003 mly->mly_event_change) { 1004 mly->mly_event_change = 1005 le32toh(mly->mly_mmbox->mmm_health.status.change_counter); 1006 mly->mly_event_waiting = 1007 le32toh(mly->mly_mmbox->mmm_health.status.next_event); 1008 1009 /* Wake up anyone that might be interested in this. */ 1010 wakeup(&mly->mly_event_change); 1011 } 1012 1013 bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap, 1014 offsetof(struct mly_mmbox, mmm_health), 1015 sizeof(mly->mly_mmbox->mmm_health), 1016 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD); 1017 1018 if (mly->mly_event_counter != mly->mly_event_waiting) 1019 mly_fetch_event(mly); 1020 } 1021 1022 /* 1023 * Fetch one event from the controller. If we fail due to resource 1024 * starvation, we'll be retried the next time a command completes. 1025 */ 1026 static void 1027 mly_fetch_event(struct mly_softc *mly) 1028 { 1029 struct mly_ccb *mc; 1030 struct mly_cmd_ioctl *mci; 1031 int s; 1032 u_int32_t event; 1033 1034 /* Get a command. */ 1035 if (mly_ccb_alloc(mly, &mc)) 1036 return; 1037 1038 /* Set up the data buffer. */ 1039 mc->mc_data = malloc(sizeof(struct mly_event), M_DEVBUF, 1040 M_NOWAIT|M_ZERO); 1041 1042 mc->mc_length = sizeof(struct mly_event); 1043 mc->mc_flags |= MLY_CCB_DATAIN; 1044 mc->mc_complete = mly_complete_event; 1045 1046 /* 1047 * Get an event number to fetch. It's possible that we've raced 1048 * with another context for the last event, in which case there will 1049 * be no more events. 1050 */ 1051 s = splbio(); 1052 if (mly->mly_event_counter == mly->mly_event_waiting) { 1053 splx(s); 1054 free(mc->mc_data, M_DEVBUF); 1055 mly_ccb_free(mly, mc); 1056 return; 1057 } 1058 event = mly->mly_event_counter++; 1059 splx(s); 1060 1061 /* 1062 * Build the ioctl. 1063 * 1064 * At this point we are committed to sending this request, as it 1065 * will be the only one constructed for this particular event 1066 * number. 1067 */ 1068 mci = (struct mly_cmd_ioctl *)&mc->mc_packet->ioctl; 1069 mci->opcode = MDACMD_IOCTL; 1070 mci->data_size = htole32(sizeof(struct mly_event)); 1071 _lto3l(MLY_PHYADDR(0, 0, (event >> 16) & 0xff, (event >> 24) & 0xff), 1072 mci->addr); 1073 mci->timeout = 30 | MLY_TIMEOUT_SECONDS; 1074 mci->sub_ioctl = MDACIOCTL_GETEVENT; 1075 mci->param.getevent.sequence_number_low = htole16(event & 0xffff); 1076 1077 /* 1078 * Submit the command. 1079 */ 1080 if (mly_ccb_map(mly, mc) != 0) 1081 goto bad; 1082 mly_ccb_enqueue(mly, mc); 1083 return; 1084 1085 bad: 1086 printf("%s: couldn't fetch event %u\n", device_xname(&mly->mly_dv), event); 1087 free(mc->mc_data, M_DEVBUF); 1088 mly_ccb_free(mly, mc); 1089 } 1090 1091 /* 1092 * Handle the completion of an event poll. 1093 */ 1094 static void 1095 mly_complete_event(struct mly_softc *mly, struct mly_ccb *mc) 1096 { 1097 struct mly_event *me; 1098 1099 me = (struct mly_event *)mc->mc_data; 1100 mly_ccb_unmap(mly, mc); 1101 mly_ccb_free(mly, mc); 1102 1103 /* If the event was successfully fetched, process it. */ 1104 if (mc->mc_status == SCSI_OK) 1105 mly_process_event(mly, me); 1106 else 1107 aprint_error_dev(&mly->mly_dv, "unable to fetch event; status = 0x%x\n", 1108 mc->mc_status); 1109 1110 free(me, M_DEVBUF); 1111 1112 /* Check for another event. */ 1113 mly_check_event(mly); 1114 } 1115 1116 /* 1117 * Process a controller event. Called with interrupts blocked (i.e., at 1118 * interrupt time). 1119 */ 1120 static void 1121 mly_process_event(struct mly_softc *mly, struct mly_event *me) 1122 { 1123 struct scsi_sense_data *ssd; 1124 int bus, target, event, class, action; 1125 const char *fp, *tp; 1126 1127 ssd = (struct scsi_sense_data *)&me->sense[0]; 1128 1129 /* 1130 * Errors can be reported using vendor-unique sense data. In this 1131 * case, the event code will be 0x1c (Request sense data present), 1132 * the sense key will be 0x09 (vendor specific), the MSB of the ASC 1133 * will be set, and the actual event code will be a 16-bit value 1134 * comprised of the ASCQ (low byte) and low seven bits of the ASC 1135 * (low seven bits of the high byte). 1136 */ 1137 if (le32toh(me->code) == 0x1c && 1138 SSD_SENSE_KEY(ssd->flags) == SKEY_VENDOR_SPECIFIC && 1139 (ssd->asc & 0x80) != 0) { 1140 event = ((int)(ssd->asc & ~0x80) << 8) + 1141 ssd->ascq; 1142 } else 1143 event = le32toh(me->code); 1144 1145 /* Look up event, get codes. */ 1146 fp = mly_describe_code(mly_table_event, event); 1147 1148 /* Quiet event? */ 1149 class = fp[0]; 1150 #ifdef notyet 1151 if (isupper(class) && bootverbose) 1152 class = tolower(class); 1153 #endif 1154 1155 /* Get action code, text string. */ 1156 action = fp[1]; 1157 tp = fp + 3; 1158 1159 /* 1160 * Print some information about the event. 1161 * 1162 * This code uses a table derived from the corresponding portion of 1163 * the Linux driver, and thus the parser is very similar. 1164 */ 1165 switch (class) { 1166 case 'p': 1167 /* 1168 * Error on physical drive. 1169 */ 1170 printf("%s: physical device %d:%d %s\n", device_xname(&mly->mly_dv), 1171 me->channel, me->target, tp); 1172 if (action == 'r') 1173 mly->mly_btl[me->channel][me->target].mb_flags |= 1174 MLY_BTL_RESCAN; 1175 break; 1176 1177 case 'l': 1178 case 'm': 1179 /* 1180 * Error on logical unit, or message about logical unit. 1181 */ 1182 bus = MLY_LOGDEV_BUS(mly, me->lun); 1183 target = MLY_LOGDEV_TARGET(mly, me->lun); 1184 printf("%s: logical device %d:%d %s\n", device_xname(&mly->mly_dv), 1185 bus, target, tp); 1186 if (action == 'r') 1187 mly->mly_btl[bus][target].mb_flags |= MLY_BTL_RESCAN; 1188 break; 1189 1190 case 's': 1191 /* 1192 * Report of sense data. 1193 */ 1194 if ((SSD_SENSE_KEY(ssd->flags) == SKEY_NO_SENSE || 1195 SSD_SENSE_KEY(ssd->flags) == SKEY_NOT_READY) && 1196 ssd->asc == 0x04 && 1197 (ssd->ascq == 0x01 || 1198 ssd->ascq == 0x02)) { 1199 /* Ignore NO_SENSE or NOT_READY in one case */ 1200 break; 1201 } 1202 1203 /* 1204 * XXX Should translate this if SCSIVERBOSE. 1205 */ 1206 printf("%s: physical device %d:%d %s\n", device_xname(&mly->mly_dv), 1207 me->channel, me->target, tp); 1208 printf("%s: sense key %d asc %02x ascq %02x\n", 1209 device_xname(&mly->mly_dv), SSD_SENSE_KEY(ssd->flags), 1210 ssd->asc, ssd->ascq); 1211 printf("%s: info %x%x%x%x csi %x%x%x%x\n", 1212 device_xname(&mly->mly_dv), ssd->info[0], ssd->info[1], 1213 ssd->info[2], ssd->info[3], ssd->csi[0], 1214 ssd->csi[1], ssd->csi[2], 1215 ssd->csi[3]); 1216 if (action == 'r') 1217 mly->mly_btl[me->channel][me->target].mb_flags |= 1218 MLY_BTL_RESCAN; 1219 break; 1220 1221 case 'e': 1222 printf("%s: ", device_xname(&mly->mly_dv)); 1223 printf(tp, me->target, me->lun); 1224 break; 1225 1226 case 'c': 1227 printf("%s: controller %s\n", device_xname(&mly->mly_dv), tp); 1228 break; 1229 1230 case '?': 1231 printf("%s: %s - %d\n", device_xname(&mly->mly_dv), tp, event); 1232 break; 1233 1234 default: 1235 /* Probably a 'noisy' event being ignored. */ 1236 break; 1237 } 1238 } 1239 1240 /* 1241 * Perform periodic activities. 1242 */ 1243 static void 1244 mly_thread(void *cookie) 1245 { 1246 struct mly_softc *mly; 1247 struct mly_btl *btl; 1248 int s, bus, target, done; 1249 1250 mly = (struct mly_softc *)cookie; 1251 1252 for (;;) { 1253 /* Check for new events. */ 1254 mly_check_event(mly); 1255 1256 /* Re-scan up to 1 device. */ 1257 s = splbio(); 1258 done = 0; 1259 for (bus = 0; bus < mly->mly_nchans && !done; bus++) { 1260 for (target = 0; target < MLY_MAX_TARGETS; target++) { 1261 /* Perform device rescan? */ 1262 btl = &mly->mly_btl[bus][target]; 1263 if ((btl->mb_flags & MLY_BTL_RESCAN) != 0) { 1264 btl->mb_flags ^= MLY_BTL_RESCAN; 1265 mly_scan_btl(mly, bus, target); 1266 done = 1; 1267 break; 1268 } 1269 } 1270 } 1271 splx(s); 1272 1273 /* Sleep for N seconds. */ 1274 tsleep(mly_thread, PWAIT, "mlyzzz", 1275 hz * MLY_PERIODIC_INTERVAL); 1276 } 1277 } 1278 1279 /* 1280 * Submit a command to the controller and poll on completion. Return 1281 * non-zero on timeout. 1282 */ 1283 static int 1284 mly_ccb_poll(struct mly_softc *mly, struct mly_ccb *mc, int timo) 1285 { 1286 int rv; 1287 1288 if ((rv = mly_ccb_submit(mly, mc)) != 0) 1289 return (rv); 1290 1291 for (timo *= 10; timo != 0; timo--) { 1292 if ((mc->mc_flags & MLY_CCB_COMPLETE) != 0) 1293 break; 1294 mly_intr(mly); 1295 DELAY(100); 1296 } 1297 1298 return (timo == 0); 1299 } 1300 1301 /* 1302 * Submit a command to the controller and sleep on completion. Return 1303 * non-zero on timeout. 1304 */ 1305 static int 1306 mly_ccb_wait(struct mly_softc *mly, struct mly_ccb *mc, int timo) 1307 { 1308 int rv, s; 1309 1310 mly_ccb_enqueue(mly, mc); 1311 1312 s = splbio(); 1313 if ((mc->mc_flags & MLY_CCB_COMPLETE) != 0) { 1314 splx(s); 1315 return (0); 1316 } 1317 rv = tsleep(mc, PRIBIO, "mlywccb", timo * hz / 1000); 1318 splx(s); 1319 1320 return (rv); 1321 } 1322 1323 /* 1324 * If a CCB is specified, enqueue it. Pull CCBs off the software queue in 1325 * the order that they were enqueued and try to submit their command blocks 1326 * to the controller for execution. 1327 */ 1328 void 1329 mly_ccb_enqueue(struct mly_softc *mly, struct mly_ccb *mc) 1330 { 1331 int s; 1332 1333 s = splbio(); 1334 1335 if (mc != NULL) 1336 SIMPLEQ_INSERT_TAIL(&mly->mly_ccb_queue, mc, mc_link.simpleq); 1337 1338 while ((mc = SIMPLEQ_FIRST(&mly->mly_ccb_queue)) != NULL) { 1339 if (mly_ccb_submit(mly, mc)) 1340 break; 1341 SIMPLEQ_REMOVE_HEAD(&mly->mly_ccb_queue, mc_link.simpleq); 1342 } 1343 1344 splx(s); 1345 } 1346 1347 /* 1348 * Deliver a command to the controller. 1349 */ 1350 static int 1351 mly_ccb_submit(struct mly_softc *mly, struct mly_ccb *mc) 1352 { 1353 union mly_cmd_packet *pkt; 1354 int s, off; 1355 1356 mc->mc_packet->generic.command_id = htole16(mc->mc_slot); 1357 1358 bus_dmamap_sync(mly->mly_dmat, mly->mly_pkt_dmamap, 1359 mc->mc_packetphys - mly->mly_pkt_busaddr, 1360 sizeof(union mly_cmd_packet), 1361 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 1362 1363 s = splbio(); 1364 1365 /* 1366 * Do we have to use the hardware mailbox? 1367 */ 1368 if ((mly->mly_state & MLY_STATE_MMBOX_ACTIVE) == 0) { 1369 /* 1370 * Check to see if the controller is ready for us. 1371 */ 1372 if (mly_idbr_true(mly, MLY_HM_CMDSENT)) { 1373 splx(s); 1374 return (EBUSY); 1375 } 1376 1377 /* 1378 * It's ready, send the command. 1379 */ 1380 mly_outl(mly, mly->mly_cmd_mailbox, 1381 (u_int64_t)mc->mc_packetphys & 0xffffffff); 1382 mly_outl(mly, mly->mly_cmd_mailbox + 4, 1383 (u_int64_t)mc->mc_packetphys >> 32); 1384 mly_outb(mly, mly->mly_idbr, MLY_HM_CMDSENT); 1385 } else { 1386 pkt = &mly->mly_mmbox->mmm_command[mly->mly_mmbox_cmd_idx]; 1387 off = (char *)pkt - (char *)mly->mly_mmbox; 1388 1389 bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap, 1390 off, sizeof(mly->mly_mmbox->mmm_command[0]), 1391 BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD); 1392 1393 /* Check to see if the next index is free yet. */ 1394 if (pkt->mmbox.flag != 0) { 1395 splx(s); 1396 return (EBUSY); 1397 } 1398 1399 /* Copy in new command */ 1400 memcpy(pkt->mmbox.data, mc->mc_packet->mmbox.data, 1401 sizeof(pkt->mmbox.data)); 1402 1403 /* Copy flag last. */ 1404 pkt->mmbox.flag = mc->mc_packet->mmbox.flag; 1405 1406 bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap, 1407 off, sizeof(mly->mly_mmbox->mmm_command[0]), 1408 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD); 1409 1410 /* Signal controller and update index. */ 1411 mly_outb(mly, mly->mly_idbr, MLY_AM_CMDSENT); 1412 mly->mly_mmbox_cmd_idx = 1413 (mly->mly_mmbox_cmd_idx + 1) % MLY_MMBOX_COMMANDS; 1414 } 1415 1416 splx(s); 1417 return (0); 1418 } 1419 1420 /* 1421 * Pick up completed commands from the controller and handle accordingly. 1422 */ 1423 int 1424 mly_intr(void *cookie) 1425 { 1426 struct mly_ccb *mc; 1427 union mly_status_packet *sp; 1428 u_int16_t slot; 1429 int forus, off; 1430 struct mly_softc *mly; 1431 1432 mly = cookie; 1433 forus = 0; 1434 1435 /* 1436 * Pick up hardware-mailbox commands. 1437 */ 1438 if (mly_odbr_true(mly, MLY_HM_STSREADY)) { 1439 slot = mly_inw(mly, mly->mly_status_mailbox); 1440 1441 if (slot < MLY_SLOT_MAX) { 1442 mc = mly->mly_ccbs + (slot - MLY_SLOT_START); 1443 mc->mc_status = 1444 mly_inb(mly, mly->mly_status_mailbox + 2); 1445 mc->mc_sense = 1446 mly_inb(mly, mly->mly_status_mailbox + 3); 1447 mc->mc_resid = 1448 mly_inl(mly, mly->mly_status_mailbox + 4); 1449 1450 mly_ccb_complete(mly, mc); 1451 } else { 1452 /* Slot 0xffff may mean "extremely bogus command". */ 1453 printf("%s: got HM completion for illegal slot %u\n", 1454 device_xname(&mly->mly_dv), slot); 1455 } 1456 1457 /* Unconditionally acknowledge status. */ 1458 mly_outb(mly, mly->mly_odbr, MLY_HM_STSREADY); 1459 mly_outb(mly, mly->mly_idbr, MLY_HM_STSACK); 1460 forus = 1; 1461 } 1462 1463 /* 1464 * Pick up memory-mailbox commands. 1465 */ 1466 if (mly_odbr_true(mly, MLY_AM_STSREADY)) { 1467 for (;;) { 1468 sp = &mly->mly_mmbox->mmm_status[mly->mly_mmbox_sts_idx]; 1469 off = (char *)sp - (char *)mly->mly_mmbox; 1470 1471 bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap, 1472 off, sizeof(mly->mly_mmbox->mmm_command[0]), 1473 BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD); 1474 1475 /* Check for more status. */ 1476 if (sp->mmbox.flag == 0) 1477 break; 1478 1479 /* Get slot number. */ 1480 slot = le16toh(sp->status.command_id); 1481 if (slot < MLY_SLOT_MAX) { 1482 mc = mly->mly_ccbs + (slot - MLY_SLOT_START); 1483 mc->mc_status = sp->status.status; 1484 mc->mc_sense = sp->status.sense_length; 1485 mc->mc_resid = le32toh(sp->status.residue); 1486 mly_ccb_complete(mly, mc); 1487 } else { 1488 /* 1489 * Slot 0xffff may mean "extremely bogus 1490 * command". 1491 */ 1492 printf("%s: got AM completion for illegal " 1493 "slot %u at %d\n", device_xname(&mly->mly_dv), 1494 slot, mly->mly_mmbox_sts_idx); 1495 } 1496 1497 /* Clear and move to next index. */ 1498 sp->mmbox.flag = 0; 1499 mly->mly_mmbox_sts_idx = 1500 (mly->mly_mmbox_sts_idx + 1) % MLY_MMBOX_STATUS; 1501 } 1502 1503 /* Acknowledge that we have collected status value(s). */ 1504 mly_outb(mly, mly->mly_odbr, MLY_AM_STSREADY); 1505 forus = 1; 1506 } 1507 1508 /* 1509 * Run the queue. 1510 */ 1511 if (forus && ! SIMPLEQ_EMPTY(&mly->mly_ccb_queue)) 1512 mly_ccb_enqueue(mly, NULL); 1513 1514 return (forus); 1515 } 1516 1517 /* 1518 * Process completed commands 1519 */ 1520 static void 1521 mly_ccb_complete(struct mly_softc *mly, struct mly_ccb *mc) 1522 { 1523 void (*complete)(struct mly_softc *, struct mly_ccb *); 1524 1525 bus_dmamap_sync(mly->mly_dmat, mly->mly_pkt_dmamap, 1526 mc->mc_packetphys - mly->mly_pkt_busaddr, 1527 sizeof(union mly_cmd_packet), 1528 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 1529 1530 complete = mc->mc_complete; 1531 mc->mc_flags |= MLY_CCB_COMPLETE; 1532 1533 /* 1534 * Call completion handler or wake up sleeping consumer. 1535 */ 1536 if (complete != NULL) 1537 (*complete)(mly, mc); 1538 else 1539 wakeup(mc); 1540 } 1541 1542 /* 1543 * Allocate a command. 1544 */ 1545 int 1546 mly_ccb_alloc(struct mly_softc *mly, struct mly_ccb **mcp) 1547 { 1548 struct mly_ccb *mc; 1549 int s; 1550 1551 s = splbio(); 1552 mc = SLIST_FIRST(&mly->mly_ccb_free); 1553 if (mc != NULL) 1554 SLIST_REMOVE_HEAD(&mly->mly_ccb_free, mc_link.slist); 1555 splx(s); 1556 1557 *mcp = mc; 1558 return (mc == NULL ? EAGAIN : 0); 1559 } 1560 1561 /* 1562 * Release a command back to the freelist. 1563 */ 1564 void 1565 mly_ccb_free(struct mly_softc *mly, struct mly_ccb *mc) 1566 { 1567 int s; 1568 1569 /* 1570 * Fill in parts of the command that may cause confusion if a 1571 * consumer doesn't when we are later allocated. 1572 */ 1573 mc->mc_data = NULL; 1574 mc->mc_flags = 0; 1575 mc->mc_complete = NULL; 1576 mc->mc_private = NULL; 1577 mc->mc_packet->generic.command_control = 0; 1578 1579 /* 1580 * By default, we set up to overwrite the command packet with sense 1581 * information. 1582 */ 1583 mc->mc_packet->generic.sense_buffer_address = 1584 htole64(mc->mc_packetphys); 1585 mc->mc_packet->generic.maximum_sense_size = 1586 sizeof(union mly_cmd_packet); 1587 1588 s = splbio(); 1589 SLIST_INSERT_HEAD(&mly->mly_ccb_free, mc, mc_link.slist); 1590 splx(s); 1591 } 1592 1593 /* 1594 * Allocate and initialize command and packet structures. 1595 * 1596 * If the controller supports fewer than MLY_MAX_CCBS commands, limit our 1597 * allocation to that number. If we don't yet know how many commands the 1598 * controller supports, allocate a very small set (suitable for initialization 1599 * purposes only). 1600 */ 1601 static int 1602 mly_alloc_ccbs(struct mly_softc *mly) 1603 { 1604 struct mly_ccb *mc; 1605 int i, rv; 1606 1607 if (mly->mly_controllerinfo == NULL) 1608 mly->mly_ncmds = MLY_CCBS_RESV; 1609 else { 1610 i = le16toh(mly->mly_controllerinfo->maximum_parallel_commands); 1611 mly->mly_ncmds = min(MLY_MAX_CCBS, i); 1612 } 1613 1614 /* 1615 * Allocate enough space for all the command packets in one chunk 1616 * and map them permanently into controller-visible space. 1617 */ 1618 rv = mly_dmamem_alloc(mly, 1619 mly->mly_ncmds * sizeof(union mly_cmd_packet), 1620 &mly->mly_pkt_dmamap, (void **)&mly->mly_pkt, 1621 &mly->mly_pkt_busaddr, &mly->mly_pkt_seg); 1622 if (rv) 1623 return (rv); 1624 1625 mly->mly_ccbs = malloc(sizeof(struct mly_ccb) * mly->mly_ncmds, 1626 M_DEVBUF, M_NOWAIT|M_ZERO); 1627 1628 for (i = 0; i < mly->mly_ncmds; i++) { 1629 mc = mly->mly_ccbs + i; 1630 mc->mc_slot = MLY_SLOT_START + i; 1631 mc->mc_packet = mly->mly_pkt + i; 1632 mc->mc_packetphys = mly->mly_pkt_busaddr + 1633 (i * sizeof(union mly_cmd_packet)); 1634 1635 rv = bus_dmamap_create(mly->mly_dmat, MLY_MAX_XFER, 1636 MLY_MAX_SEGS, MLY_MAX_XFER, 0, 1637 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, 1638 &mc->mc_datamap); 1639 if (rv) { 1640 mly_release_ccbs(mly); 1641 return (rv); 1642 } 1643 1644 mly_ccb_free(mly, mc); 1645 } 1646 1647 return (0); 1648 } 1649 1650 /* 1651 * Free all the storage held by commands. 1652 * 1653 * Must be called with all commands on the free list. 1654 */ 1655 static void 1656 mly_release_ccbs(struct mly_softc *mly) 1657 { 1658 struct mly_ccb *mc; 1659 1660 /* Throw away command buffer DMA maps. */ 1661 while (mly_ccb_alloc(mly, &mc) == 0) 1662 bus_dmamap_destroy(mly->mly_dmat, mc->mc_datamap); 1663 1664 /* Release CCB storage. */ 1665 free(mly->mly_ccbs, M_DEVBUF); 1666 1667 /* Release the packet storage. */ 1668 mly_dmamem_free(mly, mly->mly_ncmds * sizeof(union mly_cmd_packet), 1669 mly->mly_pkt_dmamap, (void *)mly->mly_pkt, &mly->mly_pkt_seg); 1670 } 1671 1672 /* 1673 * Map a command into controller-visible space. 1674 */ 1675 static int 1676 mly_ccb_map(struct mly_softc *mly, struct mly_ccb *mc) 1677 { 1678 struct mly_cmd_generic *gen; 1679 struct mly_sg_entry *sg; 1680 bus_dma_segment_t *ds; 1681 int flg, nseg, rv; 1682 1683 #ifdef DIAGNOSTIC 1684 /* Don't map more than once. */ 1685 if ((mc->mc_flags & MLY_CCB_MAPPED) != 0) 1686 panic("mly_ccb_map: already mapped"); 1687 mc->mc_flags |= MLY_CCB_MAPPED; 1688 1689 /* Does the command have a data buffer? */ 1690 if (mc->mc_data == NULL) 1691 panic("mly_ccb_map: no data buffer"); 1692 #endif 1693 1694 rv = bus_dmamap_load(mly->mly_dmat, mc->mc_datamap, mc->mc_data, 1695 mc->mc_length, NULL, BUS_DMA_NOWAIT | BUS_DMA_STREAMING | 1696 ((mc->mc_flags & MLY_CCB_DATAIN) != 0 ? 1697 BUS_DMA_READ : BUS_DMA_WRITE)); 1698 if (rv != 0) 1699 return (rv); 1700 1701 gen = &mc->mc_packet->generic; 1702 1703 /* 1704 * Can we use the transfer structure directly? 1705 */ 1706 if ((nseg = mc->mc_datamap->dm_nsegs) <= 2) { 1707 mc->mc_sgoff = -1; 1708 sg = &gen->transfer.direct.sg[0]; 1709 } else { 1710 mc->mc_sgoff = (mc->mc_slot - MLY_SLOT_START) * 1711 MLY_MAX_SEGS; 1712 sg = mly->mly_sg + mc->mc_sgoff; 1713 gen->command_control |= MLY_CMDCTL_EXTENDED_SG_TABLE; 1714 gen->transfer.indirect.entries[0] = htole16(nseg); 1715 gen->transfer.indirect.table_physaddr[0] = 1716 htole64(mly->mly_sg_busaddr + 1717 (mc->mc_sgoff * sizeof(struct mly_sg_entry))); 1718 } 1719 1720 /* 1721 * Fill the S/G table. 1722 */ 1723 for (ds = mc->mc_datamap->dm_segs; nseg != 0; nseg--, sg++, ds++) { 1724 sg->physaddr = htole64(ds->ds_addr); 1725 sg->length = htole64(ds->ds_len); 1726 } 1727 1728 /* 1729 * Sync up the data map. 1730 */ 1731 if ((mc->mc_flags & MLY_CCB_DATAIN) != 0) 1732 flg = BUS_DMASYNC_PREREAD; 1733 else /* if ((mc->mc_flags & MLY_CCB_DATAOUT) != 0) */ { 1734 gen->command_control |= MLY_CMDCTL_DATA_DIRECTION; 1735 flg = BUS_DMASYNC_PREWRITE; 1736 } 1737 1738 bus_dmamap_sync(mly->mly_dmat, mc->mc_datamap, 0, mc->mc_length, flg); 1739 1740 /* 1741 * Sync up the chained S/G table, if we're using one. 1742 */ 1743 if (mc->mc_sgoff == -1) 1744 return (0); 1745 1746 bus_dmamap_sync(mly->mly_dmat, mly->mly_sg_dmamap, mc->mc_sgoff, 1747 MLY_SGL_SIZE, BUS_DMASYNC_PREWRITE); 1748 1749 return (0); 1750 } 1751 1752 /* 1753 * Unmap a command from controller-visible space. 1754 */ 1755 static void 1756 mly_ccb_unmap(struct mly_softc *mly, struct mly_ccb *mc) 1757 { 1758 int flg; 1759 1760 #ifdef DIAGNOSTIC 1761 if ((mc->mc_flags & MLY_CCB_MAPPED) == 0) 1762 panic("mly_ccb_unmap: not mapped"); 1763 mc->mc_flags &= ~MLY_CCB_MAPPED; 1764 #endif 1765 1766 if ((mc->mc_flags & MLY_CCB_DATAIN) != 0) 1767 flg = BUS_DMASYNC_POSTREAD; 1768 else /* if ((mc->mc_flags & MLY_CCB_DATAOUT) != 0) */ 1769 flg = BUS_DMASYNC_POSTWRITE; 1770 1771 bus_dmamap_sync(mly->mly_dmat, mc->mc_datamap, 0, mc->mc_length, flg); 1772 bus_dmamap_unload(mly->mly_dmat, mc->mc_datamap); 1773 1774 if (mc->mc_sgoff == -1) 1775 return; 1776 1777 bus_dmamap_sync(mly->mly_dmat, mly->mly_sg_dmamap, mc->mc_sgoff, 1778 MLY_SGL_SIZE, BUS_DMASYNC_POSTWRITE); 1779 } 1780 1781 /* 1782 * Adjust the size of each I/O before it passes to the SCSI layer. 1783 */ 1784 static void 1785 mly_scsipi_minphys(struct buf *bp) 1786 { 1787 1788 if (bp->b_bcount > MLY_MAX_XFER) 1789 bp->b_bcount = MLY_MAX_XFER; 1790 minphys(bp); 1791 } 1792 1793 /* 1794 * Start a SCSI command. 1795 */ 1796 static void 1797 mly_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, 1798 void *arg) 1799 { 1800 struct mly_ccb *mc; 1801 struct mly_cmd_scsi_small *ss; 1802 struct scsipi_xfer *xs; 1803 struct scsipi_periph *periph; 1804 struct mly_softc *mly; 1805 struct mly_btl *btl; 1806 int s, tmp; 1807 1808 mly = device_private(chan->chan_adapter->adapt_dev); 1809 1810 switch (req) { 1811 case ADAPTER_REQ_RUN_XFER: 1812 xs = arg; 1813 periph = xs->xs_periph; 1814 btl = &mly->mly_btl[chan->chan_channel][periph->periph_target]; 1815 s = splbio(); 1816 tmp = btl->mb_flags; 1817 splx(s); 1818 1819 /* 1820 * Check for I/O attempt to a protected or non-existant 1821 * device. 1822 */ 1823 if ((tmp & MLY_BTL_PROTECTED) != 0) { 1824 xs->error = XS_SELTIMEOUT; 1825 scsipi_done(xs); 1826 break; 1827 } 1828 1829 #ifdef DIAGNOSTIC 1830 /* XXX Increase if/when we support large SCSI commands. */ 1831 if (xs->cmdlen > MLY_CMD_SCSI_SMALL_CDB) { 1832 printf("%s: cmd too large\n", device_xname(&mly->mly_dv)); 1833 xs->error = XS_DRIVER_STUFFUP; 1834 scsipi_done(xs); 1835 break; 1836 } 1837 #endif 1838 1839 if (mly_ccb_alloc(mly, &mc)) { 1840 xs->error = XS_RESOURCE_SHORTAGE; 1841 scsipi_done(xs); 1842 break; 1843 } 1844 1845 /* Build the command. */ 1846 mc->mc_data = xs->data; 1847 mc->mc_length = xs->datalen; 1848 mc->mc_complete = mly_scsipi_complete; 1849 mc->mc_private = xs; 1850 1851 /* Build the packet for the controller. */ 1852 ss = &mc->mc_packet->scsi_small; 1853 ss->opcode = MDACMD_SCSI; 1854 #ifdef notdef 1855 /* 1856 * XXX FreeBSD does this, but it doesn't fix anything, 1857 * XXX and appears potentially harmful. 1858 */ 1859 ss->command_control |= MLY_CMDCTL_DISABLE_DISCONNECT; 1860 #endif 1861 1862 ss->data_size = htole32(xs->datalen); 1863 _lto3l(MLY_PHYADDR(0, chan->chan_channel, 1864 periph->periph_target, periph->periph_lun), ss->addr); 1865 1866 if (xs->timeout < 60 * 1000) 1867 ss->timeout = xs->timeout / 1000 | 1868 MLY_TIMEOUT_SECONDS; 1869 else if (xs->timeout < 60 * 60 * 1000) 1870 ss->timeout = xs->timeout / (60 * 1000) | 1871 MLY_TIMEOUT_MINUTES; 1872 else 1873 ss->timeout = xs->timeout / (60 * 60 * 1000) | 1874 MLY_TIMEOUT_HOURS; 1875 1876 ss->maximum_sense_size = sizeof(xs->sense); 1877 ss->cdb_length = xs->cmdlen; 1878 memcpy(ss->cdb, xs->cmd, xs->cmdlen); 1879 1880 if (mc->mc_length != 0) { 1881 if ((xs->xs_control & XS_CTL_DATA_OUT) != 0) 1882 mc->mc_flags |= MLY_CCB_DATAOUT; 1883 else /* if ((xs->xs_control & XS_CTL_DATA_IN) != 0) */ 1884 mc->mc_flags |= MLY_CCB_DATAIN; 1885 1886 if (mly_ccb_map(mly, mc) != 0) { 1887 xs->error = XS_DRIVER_STUFFUP; 1888 mly_ccb_free(mly, mc); 1889 scsipi_done(xs); 1890 break; 1891 } 1892 } 1893 1894 /* 1895 * Give the command to the controller. 1896 */ 1897 if ((xs->xs_control & XS_CTL_POLL) != 0) { 1898 if (mly_ccb_poll(mly, mc, xs->timeout + 5000)) { 1899 xs->error = XS_REQUEUE; 1900 if (mc->mc_length != 0) 1901 mly_ccb_unmap(mly, mc); 1902 mly_ccb_free(mly, mc); 1903 scsipi_done(xs); 1904 } 1905 } else 1906 mly_ccb_enqueue(mly, mc); 1907 1908 break; 1909 1910 case ADAPTER_REQ_GROW_RESOURCES: 1911 /* 1912 * Not supported. 1913 */ 1914 break; 1915 1916 case ADAPTER_REQ_SET_XFER_MODE: 1917 /* 1918 * We can't change the transfer mode, but at least let 1919 * scsipi know what the adapter has negotiated. 1920 */ 1921 mly_get_xfer_mode(mly, chan->chan_channel, arg); 1922 break; 1923 } 1924 } 1925 1926 /* 1927 * Handle completion of a SCSI command. 1928 */ 1929 static void 1930 mly_scsipi_complete(struct mly_softc *mly, struct mly_ccb *mc) 1931 { 1932 struct scsipi_xfer *xs; 1933 struct scsipi_channel *chan; 1934 struct scsipi_inquiry_data *inq; 1935 struct mly_btl *btl; 1936 int target, sl, s; 1937 const char *p; 1938 1939 xs = mc->mc_private; 1940 xs->status = mc->mc_status; 1941 1942 /* 1943 * XXX The `resid' value as returned by the controller appears to be 1944 * bogus, so we always set it to zero. Is it perhaps the transfer 1945 * count? 1946 */ 1947 xs->resid = 0; /* mc->mc_resid; */ 1948 1949 if (mc->mc_length != 0) 1950 mly_ccb_unmap(mly, mc); 1951 1952 switch (mc->mc_status) { 1953 case SCSI_OK: 1954 /* 1955 * In order to report logical device type and status, we 1956 * overwrite the result of the INQUIRY command to logical 1957 * devices. 1958 */ 1959 if (xs->cmd->opcode == INQUIRY) { 1960 chan = xs->xs_periph->periph_channel; 1961 target = xs->xs_periph->periph_target; 1962 btl = &mly->mly_btl[chan->chan_channel][target]; 1963 1964 s = splbio(); 1965 if ((btl->mb_flags & MLY_BTL_LOGICAL) != 0) { 1966 inq = (struct scsipi_inquiry_data *)xs->data; 1967 mly_padstr(inq->vendor, "MYLEX", 8); 1968 p = mly_describe_code(mly_table_device_type, 1969 btl->mb_type); 1970 mly_padstr(inq->product, p, 16); 1971 p = mly_describe_code(mly_table_device_state, 1972 btl->mb_state); 1973 mly_padstr(inq->revision, p, 4); 1974 } 1975 splx(s); 1976 } 1977 1978 xs->error = XS_NOERROR; 1979 break; 1980 1981 case SCSI_CHECK: 1982 sl = mc->mc_sense; 1983 if (sl > sizeof(xs->sense.scsi_sense)) 1984 sl = sizeof(xs->sense.scsi_sense); 1985 memcpy(&xs->sense.scsi_sense, mc->mc_packet, sl); 1986 xs->error = XS_SENSE; 1987 break; 1988 1989 case SCSI_BUSY: 1990 case SCSI_QUEUE_FULL: 1991 xs->error = XS_BUSY; 1992 break; 1993 1994 default: 1995 printf("%s: unknown SCSI status 0x%x\n", 1996 device_xname(&mly->mly_dv), xs->status); 1997 xs->error = XS_DRIVER_STUFFUP; 1998 break; 1999 } 2000 2001 mly_ccb_free(mly, mc); 2002 scsipi_done(xs); 2003 } 2004 2005 /* 2006 * Notify scsipi about a target's transfer mode. 2007 */ 2008 static void 2009 mly_get_xfer_mode(struct mly_softc *mly, int bus, struct scsipi_xfer_mode *xm) 2010 { 2011 struct mly_btl *btl; 2012 int s; 2013 2014 btl = &mly->mly_btl[bus][xm->xm_target]; 2015 xm->xm_mode = 0; 2016 2017 s = splbio(); 2018 2019 if ((btl->mb_flags & MLY_BTL_PHYSICAL) != 0) { 2020 if (btl->mb_speed == 0) { 2021 xm->xm_period = 0; 2022 xm->xm_offset = 0; 2023 } else { 2024 xm->xm_period = 12; /* XXX */ 2025 xm->xm_offset = 8; /* XXX */ 2026 xm->xm_mode |= PERIPH_CAP_SYNC; /* XXX */ 2027 } 2028 2029 switch (btl->mb_width) { 2030 case 32: 2031 xm->xm_mode = PERIPH_CAP_WIDE32; 2032 break; 2033 case 16: 2034 xm->xm_mode = PERIPH_CAP_WIDE16; 2035 break; 2036 default: 2037 xm->xm_mode = 0; 2038 break; 2039 } 2040 } else /* ((btl->mb_flags & MLY_BTL_LOGICAL) != 0) */ { 2041 xm->xm_mode = PERIPH_CAP_WIDE16 | PERIPH_CAP_SYNC; 2042 xm->xm_period = 12; 2043 xm->xm_offset = 8; 2044 } 2045 2046 if ((btl->mb_flags & MLY_BTL_TQING) != 0) 2047 xm->xm_mode |= PERIPH_CAP_TQING; 2048 2049 splx(s); 2050 2051 scsipi_async_event(&mly->mly_chans[bus], ASYNC_EVENT_XFER_MODE, xm); 2052 } 2053 2054 /* 2055 * ioctl hook; used here only to initiate low-level rescans. 2056 */ 2057 static int 2058 mly_scsipi_ioctl(struct scsipi_channel *chan, u_long cmd, void *data, 2059 int flag, struct proc *p) 2060 { 2061 struct mly_softc *mly; 2062 int rv; 2063 2064 mly = device_private(chan->chan_adapter->adapt_dev); 2065 2066 switch (cmd) { 2067 case SCBUSIOLLSCAN: 2068 mly_scan_channel(mly, chan->chan_channel); 2069 rv = 0; 2070 break; 2071 default: 2072 rv = ENOTTY; 2073 break; 2074 } 2075 2076 return (rv); 2077 } 2078 2079 /* 2080 * Handshake with the firmware while the card is being initialized. 2081 */ 2082 static int 2083 mly_fwhandshake(struct mly_softc *mly) 2084 { 2085 u_int8_t error, param0, param1; 2086 int spinup; 2087 2088 spinup = 0; 2089 2090 /* Set HM_STSACK and let the firmware initialize. */ 2091 mly_outb(mly, mly->mly_idbr, MLY_HM_STSACK); 2092 DELAY(1000); /* too short? */ 2093 2094 /* If HM_STSACK is still true, the controller is initializing. */ 2095 if (!mly_idbr_true(mly, MLY_HM_STSACK)) 2096 return (0); 2097 2098 printf("%s: controller initialization started\n", 2099 device_xname(&mly->mly_dv)); 2100 2101 /* 2102 * Spin waiting for initialization to finish, or for a message to be 2103 * delivered. 2104 */ 2105 while (mly_idbr_true(mly, MLY_HM_STSACK)) { 2106 /* Check for a message */ 2107 if (!mly_error_valid(mly)) 2108 continue; 2109 2110 error = mly_inb(mly, mly->mly_error_status) & ~MLY_MSG_EMPTY; 2111 param0 = mly_inb(mly, mly->mly_cmd_mailbox); 2112 param1 = mly_inb(mly, mly->mly_cmd_mailbox + 1); 2113 2114 switch (error) { 2115 case MLY_MSG_SPINUP: 2116 if (!spinup) { 2117 printf("%s: drive spinup in progress\n", 2118 device_xname(&mly->mly_dv)); 2119 spinup = 1; 2120 } 2121 break; 2122 2123 case MLY_MSG_RACE_RECOVERY_FAIL: 2124 printf("%s: mirror race recovery failed - \n", 2125 device_xname(&mly->mly_dv)); 2126 printf("%s: one or more drives offline\n", 2127 device_xname(&mly->mly_dv)); 2128 break; 2129 2130 case MLY_MSG_RACE_IN_PROGRESS: 2131 printf("%s: mirror race recovery in progress\n", 2132 device_xname(&mly->mly_dv)); 2133 break; 2134 2135 case MLY_MSG_RACE_ON_CRITICAL: 2136 printf("%s: mirror race recovery on critical drive\n", 2137 device_xname(&mly->mly_dv)); 2138 break; 2139 2140 case MLY_MSG_PARITY_ERROR: 2141 printf("%s: FATAL MEMORY PARITY ERROR\n", 2142 device_xname(&mly->mly_dv)); 2143 return (ENXIO); 2144 2145 default: 2146 printf("%s: unknown initialization code 0x%x\n", 2147 device_xname(&mly->mly_dv), error); 2148 break; 2149 } 2150 } 2151 2152 return (0); 2153 } 2154 2155 /* 2156 * Space-fill a character string 2157 */ 2158 static void 2159 mly_padstr(char *dst, const char *src, int len) 2160 { 2161 2162 while (len-- > 0) { 2163 if (*src != '\0') 2164 *dst++ = *src++; 2165 else 2166 *dst++ = ' '; 2167 } 2168 } 2169 2170 /* 2171 * Allocate DMA safe memory. 2172 */ 2173 static int 2174 mly_dmamem_alloc(struct mly_softc *mly, int size, bus_dmamap_t *dmamap, 2175 void **kva, bus_addr_t *paddr, bus_dma_segment_t *seg) 2176 { 2177 int rseg, rv, state; 2178 2179 state = 0; 2180 2181 if ((rv = bus_dmamem_alloc(mly->mly_dmat, size, PAGE_SIZE, 0, 2182 seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) { 2183 aprint_error_dev(&mly->mly_dv, "dmamem_alloc = %d\n", rv); 2184 goto bad; 2185 } 2186 2187 state++; 2188 2189 if ((rv = bus_dmamem_map(mly->mly_dmat, seg, 1, size, kva, 2190 BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) { 2191 aprint_error_dev(&mly->mly_dv, "dmamem_map = %d\n", rv); 2192 goto bad; 2193 } 2194 2195 state++; 2196 2197 if ((rv = bus_dmamap_create(mly->mly_dmat, size, size, 1, 0, 2198 BUS_DMA_NOWAIT, dmamap)) != 0) { 2199 aprint_error_dev(&mly->mly_dv, "dmamap_create = %d\n", rv); 2200 goto bad; 2201 } 2202 2203 state++; 2204 2205 if ((rv = bus_dmamap_load(mly->mly_dmat, *dmamap, *kva, size, 2206 NULL, BUS_DMA_NOWAIT)) != 0) { 2207 aprint_error_dev(&mly->mly_dv, "dmamap_load = %d\n", rv); 2208 goto bad; 2209 } 2210 2211 *paddr = (*dmamap)->dm_segs[0].ds_addr; 2212 memset(*kva, 0, size); 2213 return (0); 2214 2215 bad: 2216 if (state > 2) 2217 bus_dmamap_destroy(mly->mly_dmat, *dmamap); 2218 if (state > 1) 2219 bus_dmamem_unmap(mly->mly_dmat, *kva, size); 2220 if (state > 0) 2221 bus_dmamem_free(mly->mly_dmat, seg, 1); 2222 2223 return (rv); 2224 } 2225 2226 /* 2227 * Free DMA safe memory. 2228 */ 2229 static void 2230 mly_dmamem_free(struct mly_softc *mly, int size, bus_dmamap_t dmamap, 2231 void *kva, bus_dma_segment_t *seg) 2232 { 2233 2234 bus_dmamap_unload(mly->mly_dmat, dmamap); 2235 bus_dmamap_destroy(mly->mly_dmat, dmamap); 2236 bus_dmamem_unmap(mly->mly_dmat, kva, size); 2237 bus_dmamem_free(mly->mly_dmat, seg, 1); 2238 } 2239 2240 2241 /* 2242 * Accept an open operation on the control device. 2243 */ 2244 int 2245 mlyopen(dev_t dev, int flag, int mode, struct lwp *l) 2246 { 2247 struct mly_softc *mly; 2248 2249 if ((mly = device_lookup_private(&mly_cd, minor(dev))) == NULL) 2250 return (ENXIO); 2251 if ((mly->mly_state & MLY_STATE_INITOK) == 0) 2252 return (ENXIO); 2253 if ((mly->mly_state & MLY_STATE_OPEN) != 0) 2254 return (EBUSY); 2255 2256 mly->mly_state |= MLY_STATE_OPEN; 2257 return (0); 2258 } 2259 2260 /* 2261 * Accept the last close on the control device. 2262 */ 2263 int 2264 mlyclose(dev_t dev, int flag, int mode, 2265 struct lwp *l) 2266 { 2267 struct mly_softc *mly; 2268 2269 mly = device_lookup_private(&mly_cd, minor(dev)); 2270 mly->mly_state &= ~MLY_STATE_OPEN; 2271 return (0); 2272 } 2273 2274 /* 2275 * Handle control operations. 2276 */ 2277 int 2278 mlyioctl(dev_t dev, u_long cmd, void *data, int flag, 2279 struct lwp *l) 2280 { 2281 struct mly_softc *mly; 2282 int rv; 2283 2284 mly = device_lookup_private(&mly_cd, minor(dev)); 2285 2286 switch (cmd) { 2287 case MLYIO_COMMAND: 2288 rv = kauth_authorize_device_passthru(l->l_cred, dev, 2289 KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_ALL, data); 2290 if (rv) 2291 break; 2292 2293 rv = mly_user_command(mly, (void *)data); 2294 break; 2295 case MLYIO_HEALTH: 2296 rv = mly_user_health(mly, (void *)data); 2297 break; 2298 default: 2299 rv = ENOTTY; 2300 break; 2301 } 2302 2303 return (rv); 2304 } 2305 2306 /* 2307 * Execute a command passed in from userspace. 2308 * 2309 * The control structure contains the actual command for the controller, as 2310 * well as the user-space data pointer and data size, and an optional sense 2311 * buffer size/pointer. On completion, the data size is adjusted to the 2312 * command residual, and the sense buffer size to the size of the returned 2313 * sense data. 2314 */ 2315 static int 2316 mly_user_command(struct mly_softc *mly, struct mly_user_command *uc) 2317 { 2318 struct mly_ccb *mc; 2319 int rv, mapped; 2320 2321 if ((rv = mly_ccb_alloc(mly, &mc)) != 0) 2322 return (rv); 2323 2324 mapped = 0; 2325 mc->mc_data = NULL; 2326 2327 /* 2328 * Handle data size/direction. 2329 */ 2330 if ((mc->mc_length = abs(uc->DataTransferLength)) != 0) { 2331 if (mc->mc_length > MAXPHYS) { 2332 rv = EINVAL; 2333 goto out; 2334 } 2335 2336 mc->mc_data = malloc(mc->mc_length, M_DEVBUF, M_WAITOK); 2337 if (mc->mc_data == NULL) { 2338 rv = ENOMEM; 2339 goto out; 2340 } 2341 2342 if (uc->DataTransferLength > 0) { 2343 mc->mc_flags |= MLY_CCB_DATAIN; 2344 memset(mc->mc_data, 0, mc->mc_length); 2345 } 2346 2347 if (uc->DataTransferLength < 0) { 2348 mc->mc_flags |= MLY_CCB_DATAOUT; 2349 rv = copyin(uc->DataTransferBuffer, mc->mc_data, 2350 mc->mc_length); 2351 if (rv != 0) 2352 goto out; 2353 } 2354 2355 if ((rv = mly_ccb_map(mly, mc)) != 0) 2356 goto out; 2357 mapped = 1; 2358 } 2359 2360 /* Copy in the command and execute it. */ 2361 memcpy(mc->mc_packet, &uc->CommandMailbox, sizeof(uc->CommandMailbox)); 2362 2363 if ((rv = mly_ccb_wait(mly, mc, 60000)) != 0) 2364 goto out; 2365 2366 /* Return the data to userspace. */ 2367 if (uc->DataTransferLength > 0) { 2368 rv = copyout(mc->mc_data, uc->DataTransferBuffer, 2369 mc->mc_length); 2370 if (rv != 0) 2371 goto out; 2372 } 2373 2374 /* Return the sense buffer to userspace. */ 2375 if (uc->RequestSenseLength > 0 && mc->mc_sense > 0) { 2376 rv = copyout(mc->mc_packet, uc->RequestSenseBuffer, 2377 min(uc->RequestSenseLength, mc->mc_sense)); 2378 if (rv != 0) 2379 goto out; 2380 } 2381 2382 /* Return command results to userspace (caller will copy out). */ 2383 uc->DataTransferLength = mc->mc_resid; 2384 uc->RequestSenseLength = min(uc->RequestSenseLength, mc->mc_sense); 2385 uc->CommandStatus = mc->mc_status; 2386 rv = 0; 2387 2388 out: 2389 if (mapped) 2390 mly_ccb_unmap(mly, mc); 2391 if (mc->mc_data != NULL) 2392 free(mc->mc_data, M_DEVBUF); 2393 mly_ccb_free(mly, mc); 2394 2395 return (rv); 2396 } 2397 2398 /* 2399 * Return health status to userspace. If the health change index in the 2400 * user structure does not match that currently exported by the controller, 2401 * we return the current status immediately. Otherwise, we block until 2402 * either interrupted or new status is delivered. 2403 */ 2404 static int 2405 mly_user_health(struct mly_softc *mly, struct mly_user_health *uh) 2406 { 2407 struct mly_health_status mh; 2408 int rv, s; 2409 2410 /* Fetch the current health status from userspace. */ 2411 rv = copyin(uh->HealthStatusBuffer, &mh, sizeof(mh)); 2412 if (rv != 0) 2413 return (rv); 2414 2415 /* spin waiting for a status update */ 2416 s = splbio(); 2417 if (mly->mly_event_change == mh.change_counter) 2418 rv = tsleep(&mly->mly_event_change, PRIBIO | PCATCH, 2419 "mlyhealth", 0); 2420 splx(s); 2421 2422 if (rv == 0) { 2423 /* 2424 * Copy the controller's health status buffer out (there is 2425 * a race here if it changes again). 2426 */ 2427 rv = copyout(&mly->mly_mmbox->mmm_health.status, 2428 uh->HealthStatusBuffer, sizeof(uh->HealthStatusBuffer)); 2429 } 2430 2431 return (rv); 2432 } 2433
Indexes created Mon Sep 22 13:09:51 GMT 2025