1 /*- 2 * Copyright (c) 2000 Michael Smith 3 * Copyright (c) 2003 Paul Saab 4 * Copyright (c) 2003 Vinod Kashyap 5 * Copyright (c) 2000 BSDi 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD: src/sys/dev/twe/twe_freebsd.c,v 1.2.2.9 2004/06/11 18:57:31 vkashyap Exp $ 30 * $DragonFly: src/sys/dev/raid/twe/twe_freebsd.c,v 1.25 2006/12/22 23:26:24 swildner Exp $ 31 */ 32 33 /* 34 * FreeBSD-specific code. 35 */ 36 37 #include <dev/raid/twe/twe_compat.h> 38 #include <dev/raid/twe/twereg.h> 39 #include <dev/raid/twe/twe_tables.h> 40 #include <dev/raid/twe/tweio.h> 41 #include <dev/raid/twe/twevar.h> 42 43 static devclass_t twe_devclass; 44 45 #ifdef TWE_DEBUG 46 static u_int32_t twed_bio_in; 47 #define TWED_BIO_IN twed_bio_in++ 48 static u_int32_t twed_bio_out; 49 #define TWED_BIO_OUT twed_bio_out++ 50 #else 51 #define TWED_BIO_IN 52 #define TWED_BIO_OUT 53 #endif 54 55 /******************************************************************************** 56 ******************************************************************************** 57 Control device interface 58 ******************************************************************************** 59 ********************************************************************************/ 60 61 static d_open_t twe_open; 62 static d_close_t twe_close; 63 static d_ioctl_t twe_ioctl_wrapper; 64 65 static struct dev_ops twe_ops = { 66 { "twe", TWE_CDEV_MAJOR, 0 }, 67 .d_open = twe_open, 68 .d_close = twe_close, 69 .d_ioctl = twe_ioctl_wrapper, 70 }; 71 72 /******************************************************************************** 73 * Accept an open operation on the control device. 74 */ 75 static int 76 twe_open(struct dev_open_args *ap) 77 { 78 cdev_t dev = ap->a_head.a_dev; 79 int unit = minor(dev); 80 struct twe_softc *sc = devclass_get_softc(twe_devclass, unit); 81 82 sc->twe_state |= TWE_STATE_OPEN; 83 return(0); 84 } 85 86 /******************************************************************************** 87 * Accept the last close on the control device. 88 */ 89 static int 90 twe_close(struct dev_close_args *ap) 91 { 92 cdev_t dev = ap->a_head.a_dev; 93 int unit = minor(dev); 94 struct twe_softc *sc = devclass_get_softc(twe_devclass, unit); 95 96 sc->twe_state &= ~TWE_STATE_OPEN; 97 return (0); 98 } 99 100 /******************************************************************************** 101 * Handle controller-specific control operations. 102 */ 103 static int 104 twe_ioctl_wrapper(struct dev_ioctl_args *ap) 105 { 106 cdev_t dev = ap->a_head.a_dev; 107 struct twe_softc *sc = (struct twe_softc *)dev->si_drv1; 108 109 return(twe_ioctl(sc, ap->a_cmd, ap->a_data)); 110 } 111 112 /******************************************************************************** 113 ******************************************************************************** 114 PCI device interface 115 ******************************************************************************** 116 ********************************************************************************/ 117 118 static int twe_probe(device_t dev); 119 static int twe_attach(device_t dev); 120 static void twe_free(struct twe_softc *sc); 121 static int twe_detach(device_t dev); 122 static int twe_shutdown(device_t dev); 123 static int twe_suspend(device_t dev); 124 static int twe_resume(device_t dev); 125 static void twe_pci_intr(void *arg); 126 static void twe_intrhook(void *arg); 127 static void twe_free_request(struct twe_request *tr); 128 static void twe_setup_data_dmamap(void *arg, bus_dma_segment_t *segs, 129 int nsegments, int error); 130 static void twe_setup_request_dmamap(void *arg, bus_dma_segment_t *segs, 131 int nsegments, int error); 132 133 static device_method_t twe_methods[] = { 134 /* Device interface */ 135 DEVMETHOD(device_probe, twe_probe), 136 DEVMETHOD(device_attach, twe_attach), 137 DEVMETHOD(device_detach, twe_detach), 138 DEVMETHOD(device_shutdown, twe_shutdown), 139 DEVMETHOD(device_suspend, twe_suspend), 140 DEVMETHOD(device_resume, twe_resume), 141 142 DEVMETHOD(bus_print_child, bus_generic_print_child), 143 DEVMETHOD(bus_driver_added, bus_generic_driver_added), 144 { 0, 0 } 145 }; 146 147 static driver_t twe_pci_driver = { 148 "twe", 149 twe_methods, 150 sizeof(struct twe_softc) 151 }; 152 153 #ifdef TWE_OVERRIDE 154 DRIVER_MODULE(Xtwe, pci, twe_pci_driver, twe_devclass, 0, 0); 155 #else 156 DRIVER_MODULE(twe, pci, twe_pci_driver, twe_devclass, 0, 0); 157 #endif 158 159 /******************************************************************************** 160 * Match a 3ware Escalade ATA RAID controller. 161 */ 162 static int 163 twe_probe(device_t dev) 164 { 165 166 debug_called(4); 167 168 if ((pci_get_vendor(dev) == TWE_VENDOR_ID) && 169 ((pci_get_device(dev) == TWE_DEVICE_ID) || 170 (pci_get_device(dev) == TWE_DEVICE_ID_ASIC))) { 171 device_set_desc(dev, TWE_DEVICE_NAME " driver ver. " TWE_DRIVER_VERSION_STRING); 172 #ifdef TWE_OVERRIDE 173 return(0); 174 #else 175 return(-10); 176 #endif 177 } 178 return(ENXIO); 179 } 180 181 /******************************************************************************** 182 * Allocate resources, initialise the controller. 183 */ 184 static int 185 twe_attach(device_t dev) 186 { 187 struct twe_softc *sc; 188 int rid, error; 189 u_int32_t command; 190 191 debug_called(4); 192 193 /* 194 * Initialise the softc structure. 195 */ 196 sc = device_get_softc(dev); 197 sc->twe_dev = dev; 198 199 sysctl_ctx_init(&sc->sysctl_ctx); 200 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx, 201 SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, 202 device_get_nameunit(dev), CTLFLAG_RD, 0, ""); 203 if (sc->sysctl_tree == NULL) { 204 twe_printf(sc, "cannot add sysctl tree node\n"); 205 return (ENXIO); 206 } 207 SYSCTL_ADD_STRING(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree), 208 OID_AUTO, "driver_version", CTLFLAG_RD, TWE_DRIVER_VERSION_STRING, 0, 209 "TWE driver version"); 210 211 /* 212 * Make sure we are going to be able to talk to this board. 213 */ 214 command = pci_read_config(dev, PCIR_COMMAND, 2); 215 if ((command & PCIM_CMD_PORTEN) == 0) { 216 twe_printf(sc, "register window not available\n"); 217 return(ENXIO); 218 } 219 /* 220 * Force the busmaster enable bit on, in case the BIOS forgot. 221 */ 222 command |= PCIM_CMD_BUSMASTEREN; 223 pci_write_config(dev, PCIR_COMMAND, command, 2); 224 225 /* 226 * Allocate the PCI register window. 227 */ 228 rid = TWE_IO_CONFIG_REG; 229 if ((sc->twe_io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1, RF_ACTIVE)) == NULL) { 230 twe_printf(sc, "can't allocate register window\n"); 231 twe_free(sc); 232 return(ENXIO); 233 } 234 sc->twe_btag = rman_get_bustag(sc->twe_io); 235 sc->twe_bhandle = rman_get_bushandle(sc->twe_io); 236 237 /* 238 * Allocate the parent bus DMA tag appropriate for PCI. 239 */ 240 if (bus_dma_tag_create(NULL, /* parent */ 241 1, 0, /* alignment, boundary */ 242 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 243 BUS_SPACE_MAXADDR, /* highaddr */ 244 NULL, NULL, /* filter, filterarg */ 245 MAXBSIZE, TWE_MAX_SGL_LENGTH, /* maxsize, nsegments */ 246 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 247 BUS_DMA_ALLOCNOW, /* flags */ 248 &sc->twe_parent_dmat)) { 249 twe_printf(sc, "can't allocate parent DMA tag\n"); 250 twe_free(sc); 251 return(ENOMEM); 252 } 253 254 /* 255 * Allocate and connect our interrupt. 256 */ 257 rid = 0; 258 if ((sc->twe_irq = bus_alloc_resource(sc->twe_dev, SYS_RES_IRQ, &rid, 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE)) == NULL) { 259 twe_printf(sc, "can't allocate interrupt\n"); 260 twe_free(sc); 261 return(ENXIO); 262 } 263 if (bus_setup_intr(sc->twe_dev, sc->twe_irq, 0, 264 twe_pci_intr, sc, &sc->twe_intr, NULL)) { 265 twe_printf(sc, "can't set up interrupt\n"); 266 twe_free(sc); 267 return(ENXIO); 268 } 269 270 /* 271 * Create DMA tag for mapping objects into controller-addressable space. 272 */ 273 if (bus_dma_tag_create(sc->twe_parent_dmat, /* parent */ 274 1, 0, /* alignment, boundary */ 275 BUS_SPACE_MAXADDR, /* lowaddr */ 276 BUS_SPACE_MAXADDR, /* highaddr */ 277 NULL, NULL, /* filter, filterarg */ 278 MAXBSIZE, TWE_MAX_SGL_LENGTH,/* maxsize, nsegments */ 279 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 280 0, /* flags */ 281 &sc->twe_buffer_dmat)) { 282 twe_printf(sc, "can't allocate data buffer DMA tag\n"); 283 twe_free(sc); 284 return(ENOMEM); 285 } 286 287 /* 288 * Initialise the controller and driver core. 289 */ 290 if ((error = twe_setup(sc))) { 291 twe_free(sc); 292 return(error); 293 } 294 295 /* 296 * Print some information about the controller and configuration. 297 */ 298 twe_describe_controller(sc); 299 300 /* 301 * Create the control device. 302 */ 303 dev_ops_add(&twe_ops, -1, device_get_unit(sc->twe_dev)); 304 sc->twe_dev_t = make_dev(&twe_ops, device_get_unit(sc->twe_dev), 305 UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR, "twe%d", 306 device_get_unit(sc->twe_dev)); 307 sc->twe_dev_t->si_drv1 = sc; 308 /* 309 * Schedule ourselves to bring the controller up once interrupts are available. 310 * This isn't strictly necessary, since we disable interrupts while probing the 311 * controller, but it is more in keeping with common practice for other disk 312 * devices. 313 */ 314 sc->twe_ich.ich_func = twe_intrhook; 315 sc->twe_ich.ich_arg = sc; 316 if (config_intrhook_establish(&sc->twe_ich) != 0) { 317 twe_printf(sc, "can't establish configuration hook\n"); 318 twe_free(sc); 319 return(ENXIO); 320 } 321 322 return(0); 323 } 324 325 /******************************************************************************** 326 * Free all of the resources associated with (sc). 327 * 328 * Should not be called if the controller is active. 329 */ 330 static void 331 twe_free(struct twe_softc *sc) 332 { 333 struct twe_request *tr; 334 335 debug_called(4); 336 337 /* throw away any command buffers */ 338 while ((tr = twe_dequeue_free(sc)) != NULL) 339 twe_free_request(tr); 340 341 /* destroy the data-transfer DMA tag */ 342 if (sc->twe_buffer_dmat) 343 bus_dma_tag_destroy(sc->twe_buffer_dmat); 344 345 /* disconnect the interrupt handler */ 346 if (sc->twe_intr) 347 bus_teardown_intr(sc->twe_dev, sc->twe_irq, sc->twe_intr); 348 if (sc->twe_irq != NULL) 349 bus_release_resource(sc->twe_dev, SYS_RES_IRQ, 0, sc->twe_irq); 350 351 /* destroy the parent DMA tag */ 352 if (sc->twe_parent_dmat) 353 bus_dma_tag_destroy(sc->twe_parent_dmat); 354 355 /* release the register window mapping */ 356 if (sc->twe_io != NULL) 357 bus_release_resource(sc->twe_dev, SYS_RES_IOPORT, TWE_IO_CONFIG_REG, sc->twe_io); 358 359 dev_ops_remove(&twe_ops, -1, device_get_unit(sc->twe_dev)); 360 /* destroy control device */ 361 if (sc->twe_dev_t != (cdev_t)NULL) 362 destroy_dev(sc->twe_dev_t); 363 364 sysctl_ctx_free(&sc->sysctl_ctx); 365 } 366 367 /******************************************************************************** 368 * Disconnect from the controller completely, in preparation for unload. 369 */ 370 static int 371 twe_detach(device_t dev) 372 { 373 struct twe_softc *sc = device_get_softc(dev); 374 int error; 375 376 debug_called(4); 377 378 error = EBUSY; 379 crit_enter(); 380 if (sc->twe_state & TWE_STATE_OPEN) 381 goto out; 382 383 /* 384 * Shut the controller down. 385 */ 386 if ((error = twe_shutdown(dev))) 387 goto out; 388 389 twe_free(sc); 390 391 error = 0; 392 out: 393 crit_exit(); 394 return(error); 395 } 396 397 /******************************************************************************** 398 * Bring the controller down to a dormant state and detach all child devices. 399 * 400 * Note that we can assume that the bioq on the controller is empty, as we won't 401 * allow shutdown if any device is open. 402 */ 403 static int 404 twe_shutdown(device_t dev) 405 { 406 struct twe_softc *sc = device_get_softc(dev); 407 int i, error = 0; 408 409 debug_called(4); 410 411 crit_enter(); 412 413 /* 414 * Delete all our child devices. 415 */ 416 for (i = 0; i < TWE_MAX_UNITS; i++) { 417 if (sc->twe_drive[i].td_disk != 0) 418 if ((error = twe_detach_drive(sc, i)) != 0) 419 goto out; 420 } 421 422 /* 423 * Bring the controller down. 424 */ 425 twe_deinit(sc); 426 427 out: 428 crit_exit(); 429 return(error); 430 } 431 432 /******************************************************************************** 433 * Bring the controller to a quiescent state, ready for system suspend. 434 */ 435 static int 436 twe_suspend(device_t dev) 437 { 438 struct twe_softc *sc = device_get_softc(dev); 439 440 debug_called(4); 441 442 crit_enter(); 443 sc->twe_state |= TWE_STATE_SUSPEND; 444 445 twe_disable_interrupts(sc); 446 crit_exit(); 447 448 return(0); 449 } 450 451 /******************************************************************************** 452 * Bring the controller back to a state ready for operation. 453 */ 454 static int 455 twe_resume(device_t dev) 456 { 457 struct twe_softc *sc = device_get_softc(dev); 458 459 debug_called(4); 460 461 sc->twe_state &= ~TWE_STATE_SUSPEND; 462 twe_enable_interrupts(sc); 463 464 return(0); 465 } 466 467 /******************************************************************************* 468 * Take an interrupt, or be poked by other code to look for interrupt-worthy 469 * status. 470 */ 471 static void 472 twe_pci_intr(void *arg) 473 { 474 twe_intr((struct twe_softc *)arg); 475 } 476 477 /******************************************************************************** 478 * Delayed-startup hook 479 */ 480 static void 481 twe_intrhook(void *arg) 482 { 483 struct twe_softc *sc = (struct twe_softc *)arg; 484 485 /* pull ourselves off the intrhook chain */ 486 config_intrhook_disestablish(&sc->twe_ich); 487 488 /* call core startup routine */ 489 twe_init(sc); 490 } 491 492 /******************************************************************************** 493 * Given a detected drive, attach it to the bio interface. 494 * 495 * This is called from twe_add_unit. 496 */ 497 int 498 twe_attach_drive(struct twe_softc *sc, struct twe_drive *dr) 499 { 500 char buf[80]; 501 int error = 0; 502 503 dr->td_disk = device_add_child(sc->twe_dev, NULL, -1); 504 if (dr->td_disk == NULL) { 505 twe_printf(sc, "Cannot add unit\n"); 506 return (EIO); 507 } 508 device_set_ivars(dr->td_disk, dr); 509 510 /* 511 * XXX It would make sense to test the online/initialising bits, but they seem to be 512 * always set... 513 */ 514 ksprintf(buf, "Unit %d, %s, %s", 515 dr->td_twe_unit, 516 twe_describe_code(twe_table_unittype, dr->td_type), 517 twe_describe_code(twe_table_unitstate, dr->td_state & TWE_PARAM_UNITSTATUS_MASK)); 518 device_set_desc_copy(dr->td_disk, buf); 519 520 if ((error = bus_generic_attach(sc->twe_dev)) != 0) { 521 twe_printf(sc, "Cannot attach unit to controller. error = %d\n", error); 522 error = EIO; 523 } 524 return (error); 525 } 526 527 /******************************************************************************** 528 * Detach the specified unit if it exsists 529 * 530 * This is called from twe_del_unit. 531 */ 532 int 533 twe_detach_drive(struct twe_softc *sc, int unit) 534 { 535 int error = 0; 536 537 if ((error = device_delete_child(sc->twe_dev, sc->twe_drive[unit].td_disk))) { 538 twe_printf(sc, "Cannot delete unit. error = %d\n", error); 539 return (error); 540 } 541 bzero(&sc->twe_drive[unit], sizeof(sc->twe_drive[unit])); 542 return (error); 543 } 544 545 /******************************************************************************** 546 * Clear a PCI parity error. 547 */ 548 void 549 twe_clear_pci_parity_error(struct twe_softc *sc) 550 { 551 TWE_CONTROL(sc, TWE_CONTROL_CLEAR_PARITY_ERROR); 552 pci_write_config(sc->twe_dev, PCIR_STATUS, TWE_PCI_CLEAR_PARITY_ERROR, 2); 553 } 554 555 /******************************************************************************** 556 * Clear a PCI abort. 557 */ 558 void 559 twe_clear_pci_abort(struct twe_softc *sc) 560 { 561 TWE_CONTROL(sc, TWE_CONTROL_CLEAR_PCI_ABORT); 562 pci_write_config(sc->twe_dev, PCIR_STATUS, TWE_PCI_CLEAR_PCI_ABORT, 2); 563 } 564 565 /******************************************************************************** 566 ******************************************************************************** 567 Disk device 568 ******************************************************************************** 569 ********************************************************************************/ 570 571 /* 572 * Disk device bus interface 573 */ 574 static int twed_probe(device_t dev); 575 static int twed_attach(device_t dev); 576 static int twed_detach(device_t dev); 577 578 static device_method_t twed_methods[] = { 579 DEVMETHOD(device_probe, twed_probe), 580 DEVMETHOD(device_attach, twed_attach), 581 DEVMETHOD(device_detach, twed_detach), 582 { 0, 0 } 583 }; 584 585 static driver_t twed_driver = { 586 "twed", 587 twed_methods, 588 sizeof(struct twed_softc) 589 }; 590 591 static devclass_t twed_devclass; 592 #ifdef TWE_OVERRIDE 593 DRIVER_MODULE(Xtwed, Xtwe, twed_driver, twed_devclass, 0, 0); 594 #else 595 DRIVER_MODULE(twed, twe, twed_driver, twed_devclass, 0, 0); 596 #endif 597 598 /* 599 * Disk device control interface. 600 */ 601 static d_open_t twed_open; 602 static d_close_t twed_close; 603 static d_strategy_t twed_strategy; 604 static d_dump_t twed_dump; 605 606 static struct dev_ops twed_ops = { 607 { "twed", TWED_CDEV_MAJOR, D_DISK }, 608 .d_open = twed_open, 609 .d_close = twed_close, 610 .d_read = physread, 611 .d_write = physwrite, 612 .d_strategy = twed_strategy, 613 .d_dump = twed_dump, 614 }; 615 616 #ifdef FREEBSD_4 617 static int disks_registered = 0; 618 #endif 619 620 /******************************************************************************** 621 * Handle open from generic layer. 622 * 623 * Note that this is typically only called by the diskslice code, and not 624 * for opens on subdevices (eg. slices, partitions). 625 */ 626 static int 627 twed_open(struct dev_open_args *ap) 628 { 629 cdev_t dev = ap->a_head.a_dev; 630 struct twed_softc *sc = (struct twed_softc *)dev->si_drv1; 631 struct disklabel *label; 632 633 debug_called(4); 634 635 if (sc == NULL) 636 return (ENXIO); 637 638 /* check that the controller is up and running */ 639 if (sc->twed_controller->twe_state & TWE_STATE_SHUTDOWN) 640 return(ENXIO); 641 642 /* build synthetic label */ 643 label = &sc->twed_disk.d_label; 644 bzero(label, sizeof(*label)); 645 label->d_type = DTYPE_ESDI; 646 label->d_secsize = TWE_BLOCK_SIZE; 647 label->d_nsectors = sc->twed_drive->td_sectors; 648 label->d_ntracks = sc->twed_drive->td_heads; 649 label->d_ncylinders = sc->twed_drive->td_cylinders; 650 label->d_secpercyl = sc->twed_drive->td_sectors * sc->twed_drive->td_heads; 651 label->d_secperunit = sc->twed_drive->td_size; 652 653 sc->twed_flags |= TWED_OPEN; 654 return (0); 655 } 656 657 /******************************************************************************** 658 * Handle last close of the disk device. 659 */ 660 static int 661 twed_close(struct dev_close_args *ap) 662 { 663 cdev_t dev = ap->a_head.a_dev; 664 struct twed_softc *sc = (struct twed_softc *)dev->si_drv1; 665 666 debug_called(4); 667 668 if (sc == NULL) 669 return (ENXIO); 670 671 sc->twed_flags &= ~TWED_OPEN; 672 return (0); 673 } 674 675 /******************************************************************************** 676 * Handle an I/O request. 677 */ 678 static int 679 twed_strategy(struct dev_strategy_args *ap) 680 { 681 cdev_t dev = ap->a_head.a_dev; 682 struct bio *bio = ap->a_bio; 683 struct twed_softc *sc = dev->si_drv1; 684 struct buf *bp = bio->bio_buf; 685 686 bio->bio_driver_info = sc; 687 688 debug_called(4); 689 690 TWED_BIO_IN; 691 692 /* bogus disk? */ 693 if ((sc == NULL) || (!sc->twed_drive->td_disk)) { 694 bp->b_error = EINVAL; 695 bp->b_flags |= B_ERROR; 696 kprintf("twe: bio for invalid disk!\n"); 697 biodone(bio); 698 TWED_BIO_OUT; 699 return(0); 700 } 701 702 /* perform accounting */ 703 devstat_start_transaction(&sc->twed_stats); 704 705 /* queue the bio on the controller */ 706 twe_enqueue_bio(sc->twed_controller, bio); 707 708 /* poke the controller to start I/O */ 709 twe_startio(sc->twed_controller); 710 return(0); 711 } 712 713 /******************************************************************************** 714 * System crashdump support 715 */ 716 static int 717 twed_dump(struct dev_dump_args *ap) 718 { 719 cdev_t dev = ap->a_head.a_dev; 720 struct twed_softc *twed_sc = (struct twed_softc *)dev->si_drv1; 721 struct twe_softc *twe_sc = (struct twe_softc *)twed_sc->twed_controller; 722 vm_paddr_t addr = 0; 723 long blkcnt; 724 int dumppages = MAXDUMPPGS; 725 int error; 726 int i; 727 728 if (!twed_sc || !twe_sc) 729 return(ENXIO); 730 731 blkcnt = howmany(PAGE_SIZE, ap->a_secsize); 732 733 while (ap->a_count > 0) { 734 caddr_t va = NULL; 735 736 if ((ap->a_count / blkcnt) < dumppages) 737 dumppages = ap->a_count / blkcnt; 738 739 for (i = 0; i < dumppages; ++i) { 740 vm_paddr_t a = addr + (i * PAGE_SIZE); 741 if (is_physical_memory(a)) 742 va = pmap_kenter_temporary(trunc_page(a), i); 743 else 744 va = pmap_kenter_temporary(trunc_page(0), i); 745 } 746 747 if ((error = twe_dump_blocks(twe_sc, twed_sc->twed_drive->td_twe_unit, ap->a_blkno, va, 748 (PAGE_SIZE * dumppages) / TWE_BLOCK_SIZE)) != 0) 749 return(error); 750 751 752 if (dumpstatus(addr, (off_t)ap->a_count * DEV_BSIZE) < 0) 753 return(EINTR); 754 755 ap->a_blkno += blkcnt * dumppages; 756 ap->a_count -= blkcnt * dumppages; 757 addr += PAGE_SIZE * dumppages; 758 } 759 return(0); 760 } 761 762 /******************************************************************************** 763 * Handle completion of an I/O request. 764 */ 765 void 766 twed_intr(struct bio *bio) 767 { 768 struct buf *bp = bio->bio_buf; 769 struct twed_softc *sc = bio->bio_driver_info; 770 debug_called(4); 771 772 /* if no error, transfer completed */ 773 if ((bp->b_flags & B_ERROR) == 0) 774 bp->b_resid = 0; 775 devstat_end_transaction_buf(&sc->twed_stats, bp); 776 biodone(bio); 777 TWED_BIO_OUT; 778 } 779 780 /******************************************************************************** 781 * Default probe stub. 782 */ 783 static int 784 twed_probe(device_t dev) 785 { 786 return (0); 787 } 788 789 /******************************************************************************** 790 * Attach a unit to the controller. 791 */ 792 static int 793 twed_attach(device_t dev) 794 { 795 struct twed_softc *sc; 796 device_t parent; 797 cdev_t dsk; 798 799 debug_called(4); 800 801 /* initialise our softc */ 802 sc = device_get_softc(dev); 803 parent = device_get_parent(dev); 804 sc->twed_controller = (struct twe_softc *)device_get_softc(parent); 805 sc->twed_drive = device_get_ivars(dev); 806 sc->twed_drive->td_sys_unit = device_get_unit(dev); 807 sc->twed_dev = dev; 808 809 /* report the drive */ 810 twed_printf(sc, "%uMB (%u sectors)\n", 811 sc->twed_drive->td_size / ((1024 * 1024) / TWE_BLOCK_SIZE), 812 sc->twed_drive->td_size); 813 814 devstat_add_entry(&sc->twed_stats, "twed", sc->twed_drive->td_sys_unit, 815 TWE_BLOCK_SIZE, 816 DEVSTAT_NO_ORDERED_TAGS, 817 DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER, 818 DEVSTAT_PRIORITY_ARRAY); 819 820 /* attach a generic disk device to ourselves */ 821 dsk = disk_create(sc->twed_drive->td_sys_unit, &sc->twed_disk, 822 0, &twed_ops); 823 dsk->si_drv1 = sc; 824 /* dsk->si_drv2 = sc->twed_drive;*/ 825 sc->twed_dev_t = dsk; 826 #ifdef FREEBSD_4 827 disks_registered++; 828 #endif 829 830 /* set the maximum I/O size to the theoretical maximum allowed by the S/G list size */ 831 dsk->si_iosize_max = (TWE_MAX_SGL_LENGTH - 1) * PAGE_SIZE; 832 833 return (0); 834 } 835 836 /******************************************************************************** 837 * Disconnect ourselves from the system. 838 */ 839 static int 840 twed_detach(device_t dev) 841 { 842 struct twed_softc *sc = (struct twed_softc *)device_get_softc(dev); 843 844 debug_called(4); 845 846 if (sc->twed_flags & TWED_OPEN) 847 return(EBUSY); 848 849 devstat_remove_entry(&sc->twed_stats); 850 disk_destroy(&sc->twed_disk); 851 #ifdef FREEBSD_4 852 kprintf("Disks registered: %d\n", disks_registered); 853 #if 0 854 if (--disks_registered == 0) 855 dev_ops_remove(&tweddisk_ops); 856 #endif 857 #endif 858 859 return(0); 860 } 861 862 /******************************************************************************** 863 ******************************************************************************** 864 Misc 865 ******************************************************************************** 866 ********************************************************************************/ 867 868 MALLOC_DEFINE(TWE_MALLOC_CLASS, "twe commands", "twe commands"); 869 /******************************************************************************** 870 * Allocate a command buffer 871 */ 872 struct twe_request * 873 twe_allocate_request(struct twe_softc *sc) 874 { 875 struct twe_request *tr; 876 int aligned_size; 877 878 /* 879 * TWE requires requests to be 512-byte aligned. Depend on malloc() 880 * guarenteeing alignment for power-of-2 requests. Note that the old 881 * (FreeBSD-4.x) malloc code aligned all requests, but the new slab 882 * allocator only guarentees same-size alignment for power-of-2 requests. 883 */ 884 aligned_size = (sizeof(struct twe_request) + TWE_ALIGNMASK) & 885 ~TWE_ALIGNMASK; 886 tr = kmalloc(aligned_size, TWE_MALLOC_CLASS, M_INTWAIT|M_ZERO); 887 tr->tr_sc = sc; 888 if (bus_dmamap_create(sc->twe_buffer_dmat, 0, &tr->tr_cmdmap)) { 889 twe_free_request(tr); 890 return(NULL); 891 } 892 bus_dmamap_load(sc->twe_buffer_dmat, tr->tr_cmdmap, &tr->tr_command, 893 sizeof(tr->tr_command), twe_setup_request_dmamap, tr, 0); 894 if (bus_dmamap_create(sc->twe_buffer_dmat, 0, &tr->tr_dmamap)) { 895 bus_dmamap_destroy(sc->twe_buffer_dmat, tr->tr_cmdmap); 896 twe_free_request(tr); 897 return(NULL); 898 } 899 return(tr); 900 } 901 902 /******************************************************************************** 903 * Permanently discard a command buffer. 904 */ 905 static void 906 twe_free_request(struct twe_request *tr) 907 { 908 struct twe_softc *sc = tr->tr_sc; 909 910 debug_called(4); 911 912 bus_dmamap_unload(sc->twe_buffer_dmat, tr->tr_cmdmap); 913 bus_dmamap_destroy(sc->twe_buffer_dmat, tr->tr_cmdmap); 914 bus_dmamap_destroy(sc->twe_buffer_dmat, tr->tr_dmamap); 915 kfree(tr, TWE_MALLOC_CLASS); 916 } 917 918 /******************************************************************************** 919 * Map/unmap (tr)'s command and data in the controller's addressable space. 920 * 921 * These routines ensure that the data which the controller is going to try to 922 * access is actually visible to the controller, in a machine-independant 923 * fashion. Due to a hardware limitation, I/O buffers must be 512-byte aligned 924 * and we take care of that here as well. 925 */ 926 static void 927 twe_fillin_sgl(TWE_SG_Entry *sgl, bus_dma_segment_t *segs, int nsegments, int max_sgl) 928 { 929 int i; 930 931 for (i = 0; i < nsegments; i++) { 932 sgl[i].address = segs[i].ds_addr; 933 sgl[i].length = segs[i].ds_len; 934 } 935 for (; i < max_sgl; i++) { /* XXX necessary? */ 936 sgl[i].address = 0; 937 sgl[i].length = 0; 938 } 939 } 940 941 static void 942 twe_setup_data_dmamap(void *arg, bus_dma_segment_t *segs, int nsegments, int error) 943 { 944 struct twe_request *tr = (struct twe_request *)arg; 945 TWE_Command *cmd = &tr->tr_command; 946 947 debug_called(4); 948 949 if (tr->tr_flags & TWE_CMD_MAPPED) 950 panic("already mapped command"); 951 952 tr->tr_flags |= TWE_CMD_MAPPED; 953 954 if (tr->tr_flags & TWE_CMD_IN_PROGRESS) 955 tr->tr_sc->twe_state &= ~TWE_STATE_FRZN; 956 /* save base of first segment in command (applicable if there only one segment) */ 957 tr->tr_dataphys = segs[0].ds_addr; 958 959 /* correct command size for s/g list size */ 960 tr->tr_command.generic.size += 2 * nsegments; 961 962 /* 963 * Due to the fact that parameter and I/O commands have the scatter/gather list in 964 * different places, we need to determine which sort of command this actually is 965 * before we can populate it correctly. 966 */ 967 switch(cmd->generic.opcode) { 968 case TWE_OP_GET_PARAM: 969 case TWE_OP_SET_PARAM: 970 cmd->generic.sgl_offset = 2; 971 twe_fillin_sgl(&cmd->param.sgl[0], segs, nsegments, TWE_MAX_SGL_LENGTH); 972 break; 973 case TWE_OP_READ: 974 case TWE_OP_WRITE: 975 cmd->generic.sgl_offset = 3; 976 twe_fillin_sgl(&cmd->io.sgl[0], segs, nsegments, TWE_MAX_SGL_LENGTH); 977 break; 978 case TWE_OP_ATA_PASSTHROUGH: 979 cmd->generic.sgl_offset = 5; 980 twe_fillin_sgl(&cmd->ata.sgl[0], segs, nsegments, TWE_MAX_ATA_SGL_LENGTH); 981 break; 982 default: 983 /* 984 * Fall back to what the linux driver does. 985 * Do this because the API may send an opcode 986 * the driver knows nothing about and this will 987 * at least stop PCIABRT's from hosing us. 988 */ 989 switch (cmd->generic.sgl_offset) { 990 case 2: 991 twe_fillin_sgl(&cmd->param.sgl[0], segs, nsegments, TWE_MAX_SGL_LENGTH); 992 break; 993 case 3: 994 twe_fillin_sgl(&cmd->io.sgl[0], segs, nsegments, TWE_MAX_SGL_LENGTH); 995 break; 996 case 5: 997 twe_fillin_sgl(&cmd->ata.sgl[0], segs, nsegments, TWE_MAX_ATA_SGL_LENGTH); 998 break; 999 } 1000 } 1001 if (tr->tr_flags & TWE_CMD_DATAIN) 1002 bus_dmamap_sync(tr->tr_sc->twe_buffer_dmat, tr->tr_dmamap, BUS_DMASYNC_PREREAD); 1003 if (tr->tr_flags & TWE_CMD_DATAOUT) { 1004 /* if we're using an alignment buffer, and we're writing data, copy the real data out */ 1005 if (tr->tr_flags & TWE_CMD_ALIGNBUF) 1006 bcopy(tr->tr_realdata, tr->tr_data, tr->tr_length); 1007 bus_dmamap_sync(tr->tr_sc->twe_buffer_dmat, tr->tr_dmamap, BUS_DMASYNC_PREWRITE); 1008 } 1009 if (twe_start(tr) == EBUSY) { 1010 tr->tr_sc->twe_state |= TWE_STATE_CTLR_BUSY; 1011 twe_requeue_ready(tr); 1012 } 1013 } 1014 1015 static void 1016 twe_setup_request_dmamap(void *arg, bus_dma_segment_t *segs, int nsegments, int error) 1017 { 1018 struct twe_request *tr = (struct twe_request *)arg; 1019 1020 debug_called(4); 1021 1022 /* command can't cross a page boundary */ 1023 tr->tr_cmdphys = segs[0].ds_addr; 1024 } 1025 1026 int 1027 twe_map_request(struct twe_request *tr) 1028 { 1029 struct twe_softc *sc = tr->tr_sc; 1030 int error = 0; 1031 1032 debug_called(4); 1033 1034 if (sc->twe_state & (TWE_STATE_CTLR_BUSY | TWE_STATE_FRZN)) { 1035 twe_requeue_ready(tr); 1036 return (EBUSY); 1037 } 1038 1039 /* 1040 * Map the command into bus space. 1041 */ 1042 bus_dmamap_sync(sc->twe_buffer_dmat, tr->tr_cmdmap, BUS_DMASYNC_PREWRITE); 1043 1044 /* 1045 * If the command involves data, map that too. 1046 */ 1047 if ((tr->tr_data != NULL) && ((tr->tr_flags & TWE_CMD_MAPPED) == 0)) { 1048 1049 /* 1050 * Data must be 512-byte aligned; allocate a fixup buffer if it's not. 1051 * 1052 * DragonFly's malloc only guarentees alignment for requests which 1053 * are power-of-2 sized. 1054 */ 1055 if (((vm_offset_t)tr->tr_data % TWE_ALIGNMENT) != 0) { 1056 int aligned_size; 1057 1058 tr->tr_realdata = tr->tr_data; /* save pointer to 'real' data */ 1059 aligned_size = TWE_ALIGNMENT; 1060 while (aligned_size < tr->tr_length) 1061 aligned_size <<= 1; 1062 tr->tr_flags |= TWE_CMD_ALIGNBUF; 1063 tr->tr_data = kmalloc(aligned_size, TWE_MALLOC_CLASS, M_INTWAIT); 1064 if (tr->tr_data == NULL) { 1065 twe_printf(sc, "%s: malloc failed\n", __func__); 1066 tr->tr_data = tr->tr_realdata; /* restore original data pointer */ 1067 return(ENOMEM); 1068 } 1069 } 1070 1071 /* 1072 * Map the data buffer into bus space and build the s/g list. 1073 */ 1074 if ((error = bus_dmamap_load(sc->twe_buffer_dmat, tr->tr_dmamap, tr->tr_data, 1075 tr->tr_length, twe_setup_data_dmamap, tr, BUS_DMA_NOWAIT) 1076 == EINPROGRESS)) { 1077 tr->tr_flags |= TWE_CMD_IN_PROGRESS; 1078 sc->twe_state |= TWE_STATE_FRZN; 1079 error = 0; 1080 } 1081 } else { 1082 if ((error = twe_start(tr)) == EBUSY) { 1083 sc->twe_state |= TWE_STATE_CTLR_BUSY; 1084 twe_requeue_ready(tr); 1085 } 1086 } 1087 1088 return(error); 1089 } 1090 1091 void 1092 twe_unmap_request(struct twe_request *tr) 1093 { 1094 struct twe_softc *sc = tr->tr_sc; 1095 debug_called(4); 1096 1097 /* 1098 * Unmap the command from bus space. 1099 */ 1100 bus_dmamap_sync(sc->twe_buffer_dmat, tr->tr_cmdmap, BUS_DMASYNC_POSTWRITE); 1101 1102 /* 1103 * If the command involved data, unmap that too. 1104 */ 1105 if (tr->tr_data != NULL) { 1106 1107 if (tr->tr_flags & TWE_CMD_DATAIN) { 1108 bus_dmamap_sync(sc->twe_buffer_dmat, tr->tr_dmamap, BUS_DMASYNC_POSTREAD); 1109 /* if we're using an alignment buffer, and we're reading data, copy the real data in */ 1110 if (tr->tr_flags & TWE_CMD_ALIGNBUF) 1111 bcopy(tr->tr_data, tr->tr_realdata, tr->tr_length); 1112 } 1113 if (tr->tr_flags & TWE_CMD_DATAOUT) 1114 bus_dmamap_sync(sc->twe_buffer_dmat, tr->tr_dmamap, BUS_DMASYNC_POSTWRITE); 1115 1116 bus_dmamap_unload(sc->twe_buffer_dmat, tr->tr_dmamap); 1117 } 1118 1119 /* free alignment buffer if it was used */ 1120 if (tr->tr_flags & TWE_CMD_ALIGNBUF) { 1121 kfree(tr->tr_data, TWE_MALLOC_CLASS); 1122 tr->tr_data = tr->tr_realdata; /* restore 'real' data pointer */ 1123 } 1124 } 1125 1126 #ifdef TWE_DEBUG 1127 void twe_report(void); 1128 /******************************************************************************** 1129 * Print current controller status, call from DDB. 1130 */ 1131 void 1132 twe_report(void) 1133 { 1134 struct twe_softc *sc; 1135 int i; 1136 1137 crit_enter(); 1138 for (i = 0; (sc = devclass_get_softc(twe_devclass, i)) != NULL; i++) 1139 twe_print_controller(sc); 1140 kprintf("twed: total bio count in %u out %u\n", twed_bio_in, twed_bio_out); 1141 crit_exit(); 1142 } 1143 #endif 1144