sys/dev/twe/twe_freebsd.c

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