1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 1999,2000 Jonathan Lemon 5 * All rights reserved. 6 * 7 # Derived from the original IDA Compaq RAID driver, which is 8 * Copyright (c) 1996, 1997, 1998, 1999 9 * Mark Dawson and David James. All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 /* 35 * Generic driver for Compaq SMART RAID adapters. 36 */ 37 38 #include <sys/param.h> 39 #include <sys/kernel.h> 40 #include <sys/systm.h> 41 #include <sys/lock.h> 42 #include <sys/malloc.h> 43 #include <sys/mutex.h> 44 #include <sys/stat.h> 45 46 #include <sys/bio.h> 47 #include <sys/bus.h> 48 #include <sys/conf.h> 49 #include <sys/endian.h> 50 51 #include <machine/bus.h> 52 #include <sys/rman.h> 53 54 #include <geom/geom_disk.h> 55 56 #include <dev/ida/idareg.h> 57 #include <dev/ida/idavar.h> 58 #include <dev/ida/idaio.h> 59 60 /* prototypes */ 61 static int ida_alloc_qcbs(struct ida_softc *ida); 62 static void ida_done(struct ida_softc *ida, struct ida_qcb *qcb); 63 static void ida_start(struct ida_softc *ida); 64 static void ida_startio(struct ida_softc *ida); 65 static void ida_startup(void *arg); 66 static void ida_timeout(void *arg); 67 static int ida_wait(struct ida_softc *ida, struct ida_qcb *qcb); 68 69 static d_ioctl_t ida_ioctl; 70 static struct cdevsw ida_cdevsw = { 71 .d_version = D_VERSION, 72 .d_ioctl = ida_ioctl, 73 .d_name = "ida", 74 }; 75 76 void 77 ida_free(struct ida_softc *ida) 78 { 79 int i; 80 81 if (ida->ih != NULL) 82 bus_teardown_intr(ida->dev, ida->irq, ida->ih); 83 84 mtx_lock(&ida->lock); 85 callout_stop(&ida->ch); 86 mtx_unlock(&ida->lock); 87 callout_drain(&ida->ch); 88 89 if (ida->buffer_dmat) { 90 for (i = 0; i < IDA_QCB_MAX; i++) 91 bus_dmamap_destroy(ida->buffer_dmat, ida->qcbs[i].dmamap); 92 bus_dma_tag_destroy(ida->buffer_dmat); 93 } 94 95 if (ida->hwqcb_dmat) { 96 if (ida->hwqcb_busaddr) 97 bus_dmamap_unload(ida->hwqcb_dmat, ida->hwqcb_dmamap); 98 if (ida->hwqcbs) 99 bus_dmamem_free(ida->hwqcb_dmat, ida->hwqcbs, 100 ida->hwqcb_dmamap); 101 bus_dma_tag_destroy(ida->hwqcb_dmat); 102 } 103 104 if (ida->qcbs != NULL) 105 free(ida->qcbs, M_DEVBUF); 106 107 if (ida->irq != NULL) 108 bus_release_resource(ida->dev, ida->irq_res_type, 109 0, ida->irq); 110 111 if (ida->parent_dmat != NULL) 112 bus_dma_tag_destroy(ida->parent_dmat); 113 114 if (ida->regs != NULL) 115 bus_release_resource(ida->dev, ida->regs_res_type, 116 ida->regs_res_id, ida->regs); 117 118 mtx_destroy(&ida->lock); 119 } 120 121 /* 122 * record bus address from bus_dmamap_load 123 */ 124 static void 125 ida_dma_map_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) 126 { 127 bus_addr_t *baddr; 128 129 baddr = (bus_addr_t *)arg; 130 *baddr = segs->ds_addr; 131 } 132 133 static __inline struct ida_qcb * 134 ida_get_qcb(struct ida_softc *ida) 135 { 136 struct ida_qcb *qcb; 137 138 if ((qcb = SLIST_FIRST(&ida->free_qcbs)) != NULL) { 139 SLIST_REMOVE_HEAD(&ida->free_qcbs, link.sle); 140 bzero(qcb->hwqcb, sizeof(struct ida_hdr) + sizeof(struct ida_req)); 141 } 142 return (qcb); 143 } 144 145 static __inline void 146 ida_free_qcb(struct ida_softc *ida, struct ida_qcb *qcb) 147 { 148 149 qcb->state = QCB_FREE; 150 qcb->buf = NULL; 151 qcb->error = 0; 152 SLIST_INSERT_HEAD(&ida->free_qcbs, qcb, link.sle); 153 } 154 155 static __inline bus_addr_t 156 idahwqcbvtop(struct ida_softc *ida, struct ida_hardware_qcb *hwqcb) 157 { 158 return (ida->hwqcb_busaddr + 159 ((bus_addr_t)hwqcb - (bus_addr_t)ida->hwqcbs)); 160 } 161 162 static __inline struct ida_qcb * 163 idahwqcbptov(struct ida_softc *ida, bus_addr_t hwqcb_addr) 164 { 165 struct ida_hardware_qcb *hwqcb; 166 167 hwqcb = (struct ida_hardware_qcb *) 168 ((bus_addr_t)ida->hwqcbs + (hwqcb_addr - ida->hwqcb_busaddr)); 169 return (hwqcb->qcb); 170 } 171 172 static int 173 ida_alloc_qcbs(struct ida_softc *ida) 174 { 175 struct ida_qcb *qcb; 176 int error, i; 177 178 for (i = 0; i < IDA_QCB_MAX; i++) { 179 qcb = &ida->qcbs[i]; 180 181 error = bus_dmamap_create(ida->buffer_dmat, /*flags*/0, &qcb->dmamap); 182 if (error != 0) 183 return (error); 184 185 qcb->ida = ida; 186 qcb->flags = QCB_FREE; 187 qcb->hwqcb = &ida->hwqcbs[i]; 188 qcb->hwqcb->qcb = qcb; 189 qcb->hwqcb_busaddr = idahwqcbvtop(ida, qcb->hwqcb); 190 SLIST_INSERT_HEAD(&ida->free_qcbs, qcb, link.sle); 191 } 192 return (0); 193 } 194 195 int 196 ida_setup(struct ida_softc *ida) 197 { 198 struct ida_controller_info cinfo; 199 device_t child; 200 int error, i, unit; 201 202 SLIST_INIT(&ida->free_qcbs); 203 STAILQ_INIT(&ida->qcb_queue); 204 bioq_init(&ida->bio_queue); 205 206 ida->qcbs = (struct ida_qcb *) 207 malloc(IDA_QCB_MAX * sizeof(struct ida_qcb), M_DEVBUF, 208 M_NOWAIT | M_ZERO); 209 if (ida->qcbs == NULL) 210 return (ENOMEM); 211 212 /* 213 * Create our DMA tags 214 */ 215 216 /* DMA tag for our hardware QCB structures */ 217 error = bus_dma_tag_create( 218 /* parent */ ida->parent_dmat, 219 /* alignment */ 1, 220 /* boundary */ 0, 221 /* lowaddr */ BUS_SPACE_MAXADDR, 222 /* highaddr */ BUS_SPACE_MAXADDR, 223 /* filter */ NULL, 224 /* filterarg */ NULL, 225 /* maxsize */ IDA_QCB_MAX * sizeof(struct ida_hardware_qcb), 226 /* nsegments */ 1, 227 /* maxsegsz */ BUS_SPACE_MAXSIZE_32BIT, 228 /* flags */ 0, 229 /* lockfunc */ NULL, 230 /* lockarg */ NULL, 231 &ida->hwqcb_dmat); 232 if (error) 233 return (ENOMEM); 234 235 /* DMA tag for mapping buffers into device space */ 236 error = bus_dma_tag_create( 237 /* parent */ ida->parent_dmat, 238 /* alignment */ 1, 239 /* boundary */ 0, 240 /* lowaddr */ BUS_SPACE_MAXADDR, 241 /* highaddr */ BUS_SPACE_MAXADDR, 242 /* filter */ NULL, 243 /* filterarg */ NULL, 244 /* maxsize */ DFLTPHYS, 245 /* nsegments */ IDA_NSEG, 246 /* maxsegsz */ BUS_SPACE_MAXSIZE_32BIT, 247 /* flags */ 0, 248 /* lockfunc */ busdma_lock_mutex, 249 /* lockarg */ &ida->lock, 250 &ida->buffer_dmat); 251 if (error) 252 return (ENOMEM); 253 254 /* Allocation of hardware QCBs */ 255 /* XXX allocation is rounded to hardware page size */ 256 error = bus_dmamem_alloc(ida->hwqcb_dmat, 257 (void **)&ida->hwqcbs, BUS_DMA_NOWAIT, &ida->hwqcb_dmamap); 258 if (error) 259 return (ENOMEM); 260 261 /* And permanently map them in */ 262 bus_dmamap_load(ida->hwqcb_dmat, ida->hwqcb_dmamap, 263 ida->hwqcbs, IDA_QCB_MAX * sizeof(struct ida_hardware_qcb), 264 ida_dma_map_cb, &ida->hwqcb_busaddr, /*flags*/0); 265 266 bzero(ida->hwqcbs, IDA_QCB_MAX * sizeof(struct ida_hardware_qcb)); 267 268 error = ida_alloc_qcbs(ida); 269 if (error) 270 return (error); 271 272 mtx_lock(&ida->lock); 273 ida->cmd.int_enable(ida, 0); 274 275 error = ida_command(ida, CMD_GET_CTRL_INFO, &cinfo, sizeof(cinfo), 276 IDA_CONTROLLER, 0, DMA_DATA_IN); 277 if (error) { 278 mtx_unlock(&ida->lock); 279 device_printf(ida->dev, "CMD_GET_CTRL_INFO failed.\n"); 280 return (error); 281 } 282 283 device_printf(ida->dev, "drives=%d firm_rev=%c%c%c%c\n", 284 cinfo.num_drvs, cinfo.firm_rev[0], cinfo.firm_rev[1], 285 cinfo.firm_rev[2], cinfo.firm_rev[3]); 286 287 if (ida->flags & IDA_FIRMWARE) { 288 int data; 289 290 error = ida_command(ida, CMD_START_FIRMWARE, 291 &data, sizeof(data), IDA_CONTROLLER, 0, DMA_DATA_IN); 292 if (error) { 293 mtx_unlock(&ida->lock); 294 device_printf(ida->dev, "CMD_START_FIRMWARE failed.\n"); 295 return (error); 296 } 297 } 298 299 ida->cmd.int_enable(ida, 1); 300 ida->flags |= IDA_ATTACHED; 301 mtx_unlock(&ida->lock); 302 303 for (i = 0; i < cinfo.num_drvs; i++) { 304 child = device_add_child(ida->dev, /*"idad"*/NULL, -1); 305 if (child != NULL) 306 device_set_ivars(child, (void *)(intptr_t)i); 307 } 308 309 ida->ich.ich_func = ida_startup; 310 ida->ich.ich_arg = ida; 311 if (config_intrhook_establish(&ida->ich) != 0) { 312 device_delete_children(ida->dev); 313 device_printf(ida->dev, "Cannot establish configuration hook\n"); 314 return (error); 315 } 316 317 unit = device_get_unit(ida->dev); 318 ida->ida_dev_t = make_dev(&ida_cdevsw, unit, 319 UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR, 320 "ida%d", unit); 321 ida->ida_dev_t->si_drv1 = ida; 322 323 return (0); 324 } 325 326 static void 327 ida_startup(void *arg) 328 { 329 struct ida_softc *ida; 330 331 ida = arg; 332 333 config_intrhook_disestablish(&ida->ich); 334 335 bus_topo_lock(); 336 bus_generic_attach(ida->dev); 337 bus_topo_unlock(); 338 } 339 340 int 341 ida_detach(device_t dev) 342 { 343 struct ida_softc *ida; 344 int error; 345 346 ida = (struct ida_softc *)device_get_softc(dev); 347 348 error = bus_generic_detach(dev); 349 if (error) 350 return (error); 351 error = device_delete_children(dev); 352 if (error) 353 return (error); 354 355 /* 356 * XXX 357 * before detaching, we must make sure that the system is 358 * quiescent; nothing mounted, no pending activity. 359 */ 360 361 /* 362 * XXX 363 * now, how are we supposed to maintain a list of our drives? 364 * iterate over our "child devices"? 365 */ 366 367 destroy_dev(ida->ida_dev_t); 368 ida_free(ida); 369 return (error); 370 } 371 372 static void 373 ida_data_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error) 374 { 375 struct ida_hardware_qcb *hwqcb; 376 struct ida_softc *ida; 377 struct ida_qcb *qcb; 378 bus_dmasync_op_t op; 379 int i; 380 381 qcb = arg; 382 ida = qcb->ida; 383 if (!dumping) 384 mtx_assert(&ida->lock, MA_OWNED); 385 if (error) { 386 qcb->error = error; 387 ida_done(ida, qcb); 388 return; 389 } 390 391 hwqcb = qcb->hwqcb; 392 hwqcb->hdr.size = htole16((sizeof(struct ida_req) + 393 sizeof(struct ida_sgb) * IDA_NSEG) >> 2); 394 395 for (i = 0; i < nsegments; i++) { 396 hwqcb->seg[i].addr = htole32(segs[i].ds_addr); 397 hwqcb->seg[i].length = htole32(segs[i].ds_len); 398 } 399 hwqcb->req.sgcount = nsegments; 400 if (qcb->flags & DMA_DATA_TRANSFER) { 401 switch (qcb->flags & DMA_DATA_TRANSFER) { 402 case DMA_DATA_TRANSFER: 403 op = BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE; 404 break; 405 case DMA_DATA_IN: 406 op = BUS_DMASYNC_PREREAD; 407 break; 408 default: 409 KASSERT((qcb->flags & DMA_DATA_TRANSFER) == 410 DMA_DATA_OUT, ("bad DMA data flags")); 411 op = BUS_DMASYNC_PREWRITE; 412 break; 413 } 414 bus_dmamap_sync(ida->buffer_dmat, qcb->dmamap, op); 415 } 416 bus_dmamap_sync(ida->hwqcb_dmat, ida->hwqcb_dmamap, 417 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD); 418 419 STAILQ_INSERT_TAIL(&ida->qcb_queue, qcb, link.stqe); 420 ida_start(ida); 421 ida->flags &= ~IDA_QFROZEN; 422 } 423 424 static int 425 ida_map_qcb(struct ida_softc *ida, struct ida_qcb *qcb, void *data, 426 bus_size_t datasize) 427 { 428 int error, flags; 429 430 if (ida->flags & IDA_INTERRUPTS) 431 flags = BUS_DMA_WAITOK; 432 else 433 flags = BUS_DMA_NOWAIT; 434 error = bus_dmamap_load(ida->buffer_dmat, qcb->dmamap, data, datasize, 435 ida_data_cb, qcb, flags); 436 if (error == EINPROGRESS) { 437 ida->flags |= IDA_QFROZEN; 438 error = 0; 439 } 440 return (error); 441 } 442 443 int 444 ida_command(struct ida_softc *ida, int command, void *data, int datasize, 445 int drive, u_int32_t pblkno, int flags) 446 { 447 struct ida_hardware_qcb *hwqcb; 448 struct ida_qcb *qcb; 449 int error; 450 451 if (!dumping) 452 mtx_assert(&ida->lock, MA_OWNED); 453 qcb = ida_get_qcb(ida); 454 455 if (qcb == NULL) { 456 device_printf(ida->dev, "out of QCBs\n"); 457 return (EAGAIN); 458 } 459 460 qcb->flags = flags | IDA_COMMAND; 461 hwqcb = qcb->hwqcb; 462 hwqcb->hdr.drive = drive; 463 hwqcb->req.blkno = htole32(pblkno); 464 hwqcb->req.bcount = htole16(howmany(datasize, DEV_BSIZE)); 465 hwqcb->req.command = command; 466 467 error = ida_map_qcb(ida, qcb, data, datasize); 468 if (error == 0) { 469 error = ida_wait(ida, qcb); 470 /* Don't free QCB on a timeout in case it later completes. */ 471 if (error) 472 return (error); 473 error = qcb->error; 474 } 475 476 /* XXX should have status returned here? */ 477 /* XXX have "status pointer" area in QCB? */ 478 479 ida_free_qcb(ida, qcb); 480 return (error); 481 } 482 483 void 484 ida_submit_buf(struct ida_softc *ida, struct bio *bp) 485 { 486 mtx_lock(&ida->lock); 487 bioq_insert_tail(&ida->bio_queue, bp); 488 ida_startio(ida); 489 mtx_unlock(&ida->lock); 490 } 491 492 static void 493 ida_startio(struct ida_softc *ida) 494 { 495 struct ida_hardware_qcb *hwqcb; 496 struct ida_qcb *qcb; 497 struct idad_softc *drv; 498 struct bio *bp; 499 int error; 500 501 mtx_assert(&ida->lock, MA_OWNED); 502 for (;;) { 503 if (ida->flags & IDA_QFROZEN) 504 return; 505 bp = bioq_first(&ida->bio_queue); 506 if (bp == NULL) 507 return; /* no more buffers */ 508 509 qcb = ida_get_qcb(ida); 510 if (qcb == NULL) 511 return; /* out of resources */ 512 513 bioq_remove(&ida->bio_queue, bp); 514 qcb->buf = bp; 515 qcb->flags = bp->bio_cmd == BIO_READ ? DMA_DATA_IN : DMA_DATA_OUT; 516 517 hwqcb = qcb->hwqcb; 518 drv = bp->bio_driver1; 519 hwqcb->hdr.drive = drv->drive; 520 hwqcb->req.blkno = bp->bio_pblkno; 521 hwqcb->req.bcount = howmany(bp->bio_bcount, DEV_BSIZE); 522 hwqcb->req.command = bp->bio_cmd == BIO_READ ? CMD_READ : CMD_WRITE; 523 524 error = ida_map_qcb(ida, qcb, bp->bio_data, bp->bio_bcount); 525 if (error) { 526 qcb->error = error; 527 ida_done(ida, qcb); 528 } 529 } 530 } 531 532 static void 533 ida_start(struct ida_softc *ida) 534 { 535 struct ida_qcb *qcb; 536 537 if (!dumping) 538 mtx_assert(&ida->lock, MA_OWNED); 539 while ((qcb = STAILQ_FIRST(&ida->qcb_queue)) != NULL) { 540 if (ida->cmd.fifo_full(ida)) 541 break; 542 STAILQ_REMOVE_HEAD(&ida->qcb_queue, link.stqe); 543 /* 544 * XXX 545 * place the qcb on an active list? 546 */ 547 548 /* Set a timeout. */ 549 if (!ida->qactive && !dumping) 550 callout_reset(&ida->ch, hz * 5, ida_timeout, ida); 551 ida->qactive++; 552 553 qcb->state = QCB_ACTIVE; 554 ida->cmd.submit(ida, qcb); 555 } 556 } 557 558 static int 559 ida_wait(struct ida_softc *ida, struct ida_qcb *qcb) 560 { 561 struct ida_qcb *qcb_done = NULL; 562 bus_addr_t completed; 563 int delay; 564 565 if (!dumping) 566 mtx_assert(&ida->lock, MA_OWNED); 567 if (ida->flags & IDA_INTERRUPTS) { 568 if (mtx_sleep(qcb, &ida->lock, PRIBIO, "idacmd", 5 * hz)) { 569 qcb->state = QCB_TIMEDOUT; 570 return (ETIMEDOUT); 571 } 572 return (0); 573 } 574 575 again: 576 delay = 5 * 1000 * 100; /* 5 sec delay */ 577 while ((completed = ida->cmd.done(ida)) == 0) { 578 if (delay-- == 0) { 579 qcb->state = QCB_TIMEDOUT; 580 return (ETIMEDOUT); 581 } 582 DELAY(10); 583 } 584 585 qcb_done = idahwqcbptov(ida, completed & ~3); 586 if (qcb_done != qcb) 587 goto again; 588 ida_done(ida, qcb); 589 return (0); 590 } 591 592 void 593 ida_intr(void *data) 594 { 595 struct ida_softc *ida; 596 struct ida_qcb *qcb; 597 bus_addr_t completed; 598 599 ida = (struct ida_softc *)data; 600 601 mtx_lock(&ida->lock); 602 if (ida->cmd.int_pending(ida) == 0) { 603 mtx_unlock(&ida->lock); 604 return; /* not our interrupt */ 605 } 606 607 while ((completed = ida->cmd.done(ida)) != 0) { 608 qcb = idahwqcbptov(ida, completed & ~3); 609 610 if (qcb == NULL || qcb->state != QCB_ACTIVE) { 611 device_printf(ida->dev, 612 "ignoring completion %jx\n", (intmax_t)completed); 613 continue; 614 } 615 /* Handle "Bad Command List" errors. */ 616 if ((completed & 3) && (qcb->hwqcb->req.error == 0)) 617 qcb->hwqcb->req.error = CMD_REJECTED; 618 ida_done(ida, qcb); 619 } 620 ida_startio(ida); 621 mtx_unlock(&ida->lock); 622 } 623 624 /* 625 * should switch out command type; may be status, not just I/O. 626 */ 627 static void 628 ida_done(struct ida_softc *ida, struct ida_qcb *qcb) 629 { 630 bus_dmasync_op_t op; 631 int active, error = 0; 632 633 /* 634 * finish up command 635 */ 636 if (!dumping) 637 mtx_assert(&ida->lock, MA_OWNED); 638 active = (qcb->state != QCB_FREE); 639 if (qcb->flags & DMA_DATA_TRANSFER && active) { 640 switch (qcb->flags & DMA_DATA_TRANSFER) { 641 case DMA_DATA_TRANSFER: 642 op = BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE; 643 break; 644 case DMA_DATA_IN: 645 op = BUS_DMASYNC_POSTREAD; 646 break; 647 default: 648 KASSERT((qcb->flags & DMA_DATA_TRANSFER) == 649 DMA_DATA_OUT, ("bad DMA data flags")); 650 op = BUS_DMASYNC_POSTWRITE; 651 break; 652 } 653 bus_dmamap_sync(ida->buffer_dmat, qcb->dmamap, op); 654 bus_dmamap_unload(ida->buffer_dmat, qcb->dmamap); 655 } 656 if (active) 657 bus_dmamap_sync(ida->hwqcb_dmat, ida->hwqcb_dmamap, 658 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 659 660 if (qcb->hwqcb->req.error & SOFT_ERROR) { 661 if (qcb->buf) 662 device_printf(ida->dev, "soft %s error\n", 663 qcb->buf->bio_cmd == BIO_READ ? 664 "read" : "write"); 665 else 666 device_printf(ida->dev, "soft error\n"); 667 } 668 if (qcb->hwqcb->req.error & HARD_ERROR) { 669 error = 1; 670 if (qcb->buf) 671 device_printf(ida->dev, "hard %s error\n", 672 qcb->buf->bio_cmd == BIO_READ ? 673 "read" : "write"); 674 else 675 device_printf(ida->dev, "hard error\n"); 676 } 677 if (qcb->hwqcb->req.error & CMD_REJECTED) { 678 error = 1; 679 device_printf(ida->dev, "invalid request\n"); 680 } 681 if (qcb->error) { 682 error = 1; 683 device_printf(ida->dev, "request failed to map: %d\n", qcb->error); 684 } 685 686 if (qcb->flags & IDA_COMMAND) { 687 if (ida->flags & IDA_INTERRUPTS) 688 wakeup(qcb); 689 if (qcb->state == QCB_TIMEDOUT) 690 ida_free_qcb(ida, qcb); 691 } else { 692 KASSERT(qcb->buf != NULL, ("ida_done(): qcb->buf is NULL!")); 693 if (error) 694 qcb->buf->bio_flags |= BIO_ERROR; 695 idad_intr(qcb->buf); 696 ida_free_qcb(ida, qcb); 697 } 698 699 if (!active) 700 return; 701 702 ida->qactive--; 703 /* Reschedule or cancel timeout */ 704 if (ida->qactive) 705 callout_reset(&ida->ch, hz * 5, ida_timeout, ida); 706 else 707 callout_stop(&ida->ch); 708 } 709 710 static void 711 ida_timeout(void *arg) 712 { 713 struct ida_softc *ida; 714 715 ida = (struct ida_softc *)arg; 716 device_printf(ida->dev, "%s() qactive %d\n", __func__, ida->qactive); 717 718 if (ida->flags & IDA_INTERRUPTS) 719 device_printf(ida->dev, "IDA_INTERRUPTS\n"); 720 721 device_printf(ida->dev, "\t R_CMD_FIFO: %08x\n" 722 "\t R_DONE_FIFO: %08x\n" 723 "\t R_INT_MASK: %08x\n" 724 "\t R_STATUS: %08x\n" 725 "\tR_INT_PENDING: %08x\n", 726 ida_inl(ida, R_CMD_FIFO), 727 ida_inl(ida, R_DONE_FIFO), 728 ida_inl(ida, R_INT_MASK), 729 ida_inl(ida, R_STATUS), 730 ida_inl(ida, R_INT_PENDING)); 731 732 return; 733 } 734 735 /* 736 * IOCTL stuff follows. 737 */ 738 struct cmd_info { 739 int cmd; 740 int len; 741 int flags; 742 }; 743 static struct cmd_info *ida_cmd_lookup(int); 744 745 static int 746 ida_ioctl (struct cdev *dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td) 747 { 748 struct ida_softc *sc; 749 struct ida_user_command *uc; 750 struct cmd_info *ci; 751 int len; 752 int flags; 753 int error; 754 int data; 755 void *daddr; 756 757 sc = (struct ida_softc *)dev->si_drv1; 758 uc = (struct ida_user_command *)addr; 759 error = 0; 760 761 switch (cmd) { 762 case IDAIO_COMMAND: 763 ci = ida_cmd_lookup(uc->command); 764 if (ci == NULL) { 765 error = EINVAL; 766 break; 767 } 768 len = ci->len; 769 flags = ci->flags; 770 if (len) 771 daddr = &uc->d.buf; 772 else { 773 daddr = &data; 774 len = sizeof(data); 775 } 776 mtx_lock(&sc->lock); 777 error = ida_command(sc, uc->command, daddr, len, 778 uc->drive, uc->blkno, flags); 779 mtx_unlock(&sc->lock); 780 break; 781 default: 782 error = ENOIOCTL; 783 break; 784 } 785 return (error); 786 } 787 788 static struct cmd_info ci_list[] = { 789 { CMD_GET_LOG_DRV_INFO, 790 sizeof(struct ida_drive_info), DMA_DATA_IN }, 791 { CMD_GET_CTRL_INFO, 792 sizeof(struct ida_controller_info), DMA_DATA_IN }, 793 { CMD_SENSE_DRV_STATUS, 794 sizeof(struct ida_drive_status), DMA_DATA_IN }, 795 { CMD_START_RECOVERY, 0, 0 }, 796 { CMD_GET_PHYS_DRV_INFO, 797 sizeof(struct ida_phys_drv_info), DMA_DATA_TRANSFER }, 798 { CMD_BLINK_DRV_LEDS, 799 sizeof(struct ida_blink_drv_leds), DMA_DATA_OUT }, 800 { CMD_SENSE_DRV_LEDS, 801 sizeof(struct ida_blink_drv_leds), DMA_DATA_IN }, 802 { CMD_GET_LOG_DRV_EXT, 803 sizeof(struct ida_drive_info_ext), DMA_DATA_IN }, 804 { CMD_RESET_CTRL, 0, 0 }, 805 { CMD_GET_CONFIG, 0, 0 }, 806 { CMD_SET_CONFIG, 0, 0 }, 807 { CMD_LABEL_LOG_DRV, 808 sizeof(struct ida_label_logical), DMA_DATA_OUT }, 809 { CMD_SET_SURFACE_DELAY, 0, 0 }, 810 { CMD_SENSE_BUS_PARAMS, 0, 0 }, 811 { CMD_SENSE_SUBSYS_INFO, 0, 0 }, 812 { CMD_SENSE_SURFACE_ATS, 0, 0 }, 813 { CMD_PASSTHROUGH, 0, 0 }, 814 { CMD_RESET_SCSI_DEV, 0, 0 }, 815 { CMD_PAUSE_BG_ACT, 0, 0 }, 816 { CMD_RESUME_BG_ACT, 0, 0 }, 817 { CMD_START_FIRMWARE, 0, 0 }, 818 { CMD_SENSE_DRV_ERR_LOG, 0, 0 }, 819 { CMD_START_CPM, 0, 0 }, 820 { CMD_SENSE_CP, 0, 0 }, 821 { CMD_STOP_CPM, 0, 0 }, 822 { CMD_FLUSH_CACHE, 0, 0 }, 823 { CMD_ACCEPT_MEDIA_EXCH, 0, 0 }, 824 { 0, 0, 0 } 825 }; 826 827 static struct cmd_info * 828 ida_cmd_lookup (int command) 829 { 830 struct cmd_info *ci; 831 832 ci = ci_list; 833 while (ci->cmd) { 834 if (ci->cmd == command) 835 return (ci); 836 ci++; 837 } 838 return (NULL); 839 } 840