sys/dev/raid/twe/twe.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  *      $FreeBSD: src/sys/dev/twe/twe.c,v 1.1.2.10 2004/06/11 18:57:31 vkashyap Exp $
  30  *      $DragonFly: src/sys/dev/raid/twe/twe.c,v 1.19 2008/01/06 16:55:51 swildner Exp $
  31  */
  32
  33 /*
  34  * Driver for the 3ware Escalade family of IDE RAID controllers.
  35  */
  36
  37 #include <dev/raid/twe/twe_compat.h>
  38 #include <dev/raid/twe/twereg.h>
  39 #define TWE_DEFINE_TABLES
  40 #include <dev/raid/twe/twe_tables.h>
  41 #include <dev/raid/twe/tweio.h>
  42 #include <dev/raid/twe/twevar.h>
  43
  44 /*
  45  * Command submission.
  46  */
  47 static int      twe_get_param_1(struct twe_softc *sc, int table_id, int param_id, u_int8_t *result);
  48 static int      twe_get_param_2(struct twe_softc *sc, int table_id, int param_id, u_int16_t *result);
  49 static int      twe_get_param_4(struct twe_softc *sc, int table_id, int param_id, u_int32_t *result);
  50 static void     *twe_get_param(struct twe_softc *sc, int table_id, int parameter_id, size_t size,
  51                                                void (* func)(struct twe_request *tr));
  52 #ifdef TWE_SHUTDOWN_NOTIFICATION
  53 static int      twe_set_param_1(struct twe_softc *sc, int table_id, int param_id, u_int8_t value);
  54 #endif
  55 #if 0
  56 static int      twe_set_param_2(struct twe_softc *sc, int table_id, int param_id, u_int16_t value);
  57 static int      twe_set_param_4(struct twe_softc *sc, int table_id, int param_id, u_int32_t value);
  58 #endif
  59 static int      twe_set_param(struct twe_softc *sc, int table_id, int param_id, int param_size,
  60                                               void *data);
  61 static int      twe_init_connection(struct twe_softc *sc, int mode);
  62 static int      twe_wait_request(struct twe_request *tr);
  63 static int      twe_immediate_request(struct twe_request *tr);
  64 static void     twe_completeio(struct twe_request *tr);
  65 static void     twe_reset(struct twe_softc *sc);
  66 static int      twe_add_unit(struct twe_softc *sc, int unit);
  67 static int      twe_del_unit(struct twe_softc *sc, int unit);
  68
  69 /*
  70  * Command I/O to controller.
  71  */
  72 static void     twe_done(struct twe_softc *sc);
  73 static void     twe_complete(struct twe_softc *sc);
  74 static int      twe_wait_status(struct twe_softc *sc, u_int32_t status, int timeout);
  75 static int      twe_drain_response_queue(struct twe_softc *sc);
  76 static int      twe_check_bits(struct twe_softc *sc, u_int32_t status_reg);
  77 static int      twe_soft_reset(struct twe_softc *sc);
  78
  79 /*
  80  * Interrupt handling.
  81  */
  82 static void     twe_host_intr(struct twe_softc *sc);
  83 static void     twe_attention_intr(struct twe_softc *sc);
  84 static void     twe_command_intr(struct twe_softc *sc);
  85
  86 /*
  87  * Asynchronous event handling.
  88  */
  89 static int      twe_fetch_aen(struct twe_softc *sc);
  90 static void     twe_handle_aen(struct twe_request *tr);
  91 static void     twe_enqueue_aen(struct twe_softc *sc, u_int16_t aen);
  92 static u_int16_t        twe_dequeue_aen(struct twe_softc *sc);
  93 static int      twe_drain_aen_queue(struct twe_softc *sc);
  94 static int      twe_find_aen(struct twe_softc *sc, u_int16_t aen);
  95
  96 /*
  97  * Command buffer management.
  98  */
  99 static int      twe_get_request(struct twe_softc *sc, struct twe_request **tr);
 100 static void     twe_release_request(struct twe_request *tr);
 101
 102 /*
 103  * Debugging.
 104  */
 105 static char     *twe_format_aen(struct twe_softc *sc, u_int16_t aen);
 106 static int      twe_report_request(struct twe_request *tr);
 107 static void     twe_panic(struct twe_softc *sc, char *reason);
 108
 109 /********************************************************************************
 110  ********************************************************************************
 111                                                                 Public Interfaces
 112  ********************************************************************************
 113  ********************************************************************************/
 114
 115 /********************************************************************************
 116  * Initialise the controller, set up driver data structures.
 117  */
 118 int
 119 twe_setup(struct twe_softc *sc)
 120 {
 121     struct twe_request  *tr;
 122     u_int32_t           status_reg;
 123     int                 i;
 124
 125     debug_called(4);
 126
 127     /*
 128      * Initialise request queues.
 129      */
 130     twe_initq_free(sc);
 131     twe_initq_bio(sc);
 132     twe_initq_ready(sc);
 133     twe_initq_busy(sc);
 134     twe_initq_complete(sc);
 135     sc->twe_wait_aen = -1;
 136
 137     /*
 138      * Allocate request structures up front.
 139      */
 140     for (i = 0; i < TWE_Q_LENGTH; i++) {
 141         if ((tr = twe_allocate_request(sc)) == NULL)
 142             return(ENOMEM);
 143         /*
 144          * Set global defaults that won't change.
 145          */
 146         tr->tr_command.generic.host_id = sc->twe_host_id;       /* controller-assigned host ID */
 147         tr->tr_command.generic.request_id = i;                  /* our index number */
 148         sc->twe_lookup[i] = tr;
 149
 150         /*
 151          * Put command onto the freelist.
 152          */
 153         twe_release_request(tr);
 154     }
 155
 156     /*
 157      * Check status register for errors, clear them.
 158      */
 159     status_reg = TWE_STATUS(sc);
 160     twe_check_bits(sc, status_reg);
 161
 162     /*
 163      * Wait for the controller to come ready.
 164      */
 165     if (twe_wait_status(sc, TWE_STATUS_MICROCONTROLLER_READY, 60)) {
 166         twe_printf(sc, "microcontroller not ready\n");
 167         return(ENXIO);
 168     }
 169
 170     /*
 171      * Disable interrupts from the card.
 172      */
 173     twe_disable_interrupts(sc);
 174
 175     /*
 176      * Soft reset the controller, look for the AEN acknowledging the reset,
 177      * check for errors, drain the response queue.
 178      */
 179     for (i = 0; i < TWE_MAX_RESET_TRIES; i++) {
 180
 181         if (i > 0)
 182             twe_printf(sc, "reset %d failed, trying again\n", i);
 183
 184         if (!twe_soft_reset(sc))
 185             break;                      /* reset process complete */
 186     }
 187     /* did we give up? */
 188     if (i >= TWE_MAX_RESET_TRIES) {
 189         twe_printf(sc, "can't initialise controller, giving up\n");
 190         return(ENXIO);
 191     }
 192
 193     return(0);
 194 }
 195
 196 static int
 197 twe_add_unit(struct twe_softc *sc, int unit)
 198 {
 199     struct twe_drive            *dr;
 200     int                         table;
 201     u_int16_t                   dsize;
 202     TWE_Param                   *drives = NULL, *param = NULL;
 203     TWE_Unit_Descriptor         *ud;
 204     int                         error = 0;
 205
 206     if (unit < 0 || unit > TWE_MAX_UNITS)
 207         return (EINVAL);
 208     /*
 209      * The controller is in a safe state, so try to find drives attached to it.
 210      */
 211     if ((drives = twe_get_param(sc, TWE_PARAM_UNITSUMMARY, TWE_PARAM_UNITSUMMARY_Status,
 212                                 TWE_MAX_UNITS, NULL)) == NULL) {
 213         twe_printf(sc, "can't detect attached units\n");
 214         return (EIO);
 215     }
 216
 217     dr = &sc->twe_drive[unit];
 218     /* check that the drive is online */
 219     if (!(drives->data[unit] & TWE_PARAM_UNITSTATUS_Online)) {
 220         error = ENXIO;
 221         goto out;
 222     }
 223
 224     table = TWE_PARAM_UNITINFO + unit;
 225
 226     if (twe_get_param_4(sc, table, TWE_PARAM_UNITINFO_Capacity, &dr->td_size)) {
 227         twe_printf(sc, "error fetching capacity for unit %d\n", unit);
 228         error = EIO;
 229         goto out;
 230     }
 231     if (twe_get_param_1(sc, table, TWE_PARAM_UNITINFO_Status, &dr->td_state)) {
 232         twe_printf(sc, "error fetching state for unit %d\n", unit);
 233         error = EIO;
 234         goto out;
 235     }
 236     if (twe_get_param_2(sc, table, TWE_PARAM_UNITINFO_DescriptorSize, &dsize)) {
 237         twe_printf(sc, "error fetching descriptor size for unit %d\n", unit);
 238         error = EIO;
 239         goto out;
 240     }
 241     if ((param = twe_get_param(sc, table, TWE_PARAM_UNITINFO_Descriptor, dsize - 3, NULL)) == NULL) {
 242         twe_printf(sc, "error fetching descriptor for unit %d\n", unit);
 243         error = EIO;
 244         goto out;
 245     }
 246     ud = (TWE_Unit_Descriptor *)param->data;
 247     dr->td_type = ud->configuration;
 248
 249     /* build synthetic geometry as per controller internal rules */
 250     if (dr->td_size > 0x200000) {
 251         dr->td_heads = 255;
 252         dr->td_sectors = 63;
 253     } else {
 254         dr->td_heads = 64;
 255         dr->td_sectors = 32;
 256     }
 257     dr->td_cylinders = dr->td_size / (dr->td_heads * dr->td_sectors);
 258     dr->td_twe_unit = unit;
 259
 260     error = twe_attach_drive(sc, dr);
 261
 262 out:
 263     if (param != NULL)
 264         kfree(param, M_DEVBUF);
 265     if (drives != NULL)
 266         kfree(drives, M_DEVBUF);
 267     return (error);
 268 }
 269
 270 static int
 271 twe_del_unit(struct twe_softc *sc, int unit)
 272 {
 273     int         error;
 274
 275     if (unit < 0 || unit >= TWE_MAX_UNITS)
 276         return (ENXIO);
 277
 278     if (sc->twe_drive[unit].td_disk == NULL)
 279         return (ENXIO);
 280
 281     error = twe_detach_drive(sc, unit);
 282     return (error);
 283 }
 284
 285 /********************************************************************************
 286  * Locate disk devices and attach children to them.
 287  */
 288 void
 289 twe_init(struct twe_softc *sc)
 290 {
 291     int                 i;
 292
 293     /*
 294      * Scan for drives
 295      */
 296     for (i = 0; i < TWE_MAX_UNITS; i++)
 297         twe_add_unit(sc, i);
 298
 299     /*
 300      * Initialise connection with controller.
 301      */
 302     twe_init_connection(sc, TWE_INIT_MESSAGE_CREDITS);
 303
 304 #ifdef TWE_SHUTDOWN_NOTIFICATION
 305     /*
 306      * Tell the controller we support shutdown notification.
 307      */
 308     twe_set_param_1(sc, TWE_PARAM_FEATURES, TWE_PARAM_FEATURES_DriverShutdown, 1);
 309 #endif
 310
 311     /*
 312      * Mark controller up and ready to run.
 313      */
 314     sc->twe_state &= ~TWE_STATE_SHUTDOWN;
 315
 316     /*
 317      * Finally enable interrupts.
 318      */
 319     twe_enable_interrupts(sc);
 320 }
 321
 322 /********************************************************************************
 323  * Stop the controller
 324  */
 325 void
 326 twe_deinit(struct twe_softc *sc)
 327 {
 328     /*
 329      * Mark the controller as shutting down, and disable any further interrupts.
 330      */
 331     sc->twe_state |= TWE_STATE_SHUTDOWN;
 332     twe_disable_interrupts(sc);
 333
 334 #ifdef TWE_SHUTDOWN_NOTIFICATION
 335     /*
 336      * Disconnect from the controller
 337      */
 338     twe_init_connection(sc, TWE_SHUTDOWN_MESSAGE_CREDITS);
 339 #endif
 340 }
 341
 342 /*******************************************************************************
 343  * Take an interrupt, or be poked by other code to look for interrupt-worthy
 344  * status.
 345  */
 346 void
 347 twe_intr(struct twe_softc *sc)
 348 {
 349     u_int32_t           status_reg;
 350
 351     debug_called(4);
 352
 353     /*
 354      * Collect current interrupt status.
 355      */
 356     status_reg = TWE_STATUS(sc);
 357     twe_check_bits(sc, status_reg);
 358
 359     /*
 360      * Dispatch based on interrupt status
 361      */
 362     if (status_reg & TWE_STATUS_HOST_INTERRUPT)
 363         twe_host_intr(sc);
 364     if (status_reg & TWE_STATUS_ATTENTION_INTERRUPT)
 365         twe_attention_intr(sc);
 366     if (status_reg & TWE_STATUS_COMMAND_INTERRUPT)
 367         twe_command_intr(sc);
 368     if (status_reg & TWE_STATUS_RESPONSE_INTERRUPT)
 369         twe_done(sc);
 370 }
 371
 372 /********************************************************************************
 373  * Pull as much work off the softc's work queue as possible and give it to the
 374  * controller.
 375  */
 376 void
 377 twe_startio(struct twe_softc *sc)
 378 {
 379     struct twe_request  *tr;
 380     TWE_Command         *cmd;
 381     struct bio          *bio;
 382     int                 error;
 383
 384     debug_called(4);
 385
 386     if (sc->twe_state & (TWE_STATE_CTLR_BUSY | TWE_STATE_FRZN))
 387             return;
 388
 389     /* spin until something prevents us from doing any work */
 390     for (;;) {
 391
 392         /* try to get a command that's already ready to go */
 393         tr = twe_dequeue_ready(sc);
 394
 395         /* build a command from an outstanding bio */
 396         if (tr == NULL) {
 397
 398             /* get a command to handle the bio with */
 399             if (twe_get_request(sc, &tr))
 400                 break;
 401
 402             /* see if there's work to be done */
 403             if ((bio = twe_dequeue_bio(sc)) == NULL) {
 404                 twe_release_request(tr);
 405                 break;
 406             }
 407
 408             /* connect the bio to the command */
 409             tr->tr_complete = twe_completeio;
 410             tr->tr_private = bio;
 411             tr->tr_data = bio->bio_buf->b_data;
 412             tr->tr_length = bio->bio_buf->b_bcount;
 413             cmd = &tr->tr_command;
 414             if (bio->bio_buf->b_cmd == BUF_CMD_READ) {
 415                 tr->tr_flags |= TWE_CMD_DATAIN;
 416                 cmd->io.opcode = TWE_OP_READ;
 417             } else {
 418                 tr->tr_flags |= TWE_CMD_DATAOUT;
 419                 cmd->io.opcode = TWE_OP_WRITE;
 420             }
 421
 422             /* build a suitable I/O command (assumes 512-byte rounded transfers) */
 423             cmd->io.size = 3;
 424             cmd->io.unit = ((struct twed_softc *)bio->bio_driver_info)->twed_drive->td_twe_unit;
 425             cmd->io.block_count = (tr->tr_length + TWE_BLOCK_SIZE - 1) / TWE_BLOCK_SIZE;
 426             cmd->io.lba = (u_int32_t)(bio->bio_offset / TWE_BLOCK_SIZE);
 427             KKASSERT(bio->bio_offset < 0x100000000ULL * TWE_BLOCK_SIZE);
 428         }
 429
 430         /* did we find something to do? */
 431         if (tr == NULL)
 432             break;
 433
 434         /* try to map and submit the command to controller */
 435         error = twe_map_request(tr);
 436
 437         if (error != 0) {
 438             if (error == EBUSY)
 439                 break;
 440             tr->tr_status = TWE_CMD_ERROR;
 441             if (tr->tr_private != NULL) {
 442                 bio = (twe_bio *)tr->tr_private;
 443                 bio->bio_buf->b_error = error;
 444                 bio->bio_buf->b_flags |= B_ERROR;
 445                 tr->tr_private = NULL;
 446                 twed_intr(bio);
 447                 twe_release_request(tr);
 448             } else if (tr->tr_flags & TWE_CMD_SLEEPER)
 449                 wakeup_one(tr); /* wakeup the sleeping owner */
 450         }
 451     }
 452 }
 453
 454 /********************************************************************************
 455  * Write blocks from memory to disk, for system crash dumps.
 456  */
 457 int
 458 twe_dump_blocks(struct twe_softc *sc, int unit, u_int64_t lba, void *data, int nblks)
 459 {
 460     struct twe_request  *tr;
 461     TWE_Command         *cmd;
 462     int                 error;
 463
 464     if (twe_get_request(sc, &tr))
 465         return(ENOMEM);
 466
 467     KKASSERT(lba < 0x100000000ULL);
 468
 469     tr->tr_data = data;
 470     tr->tr_status = TWE_CMD_SETUP;
 471     tr->tr_length = nblks * TWE_BLOCK_SIZE;
 472     tr->tr_flags = TWE_CMD_DATAOUT;
 473
 474     cmd = &tr->tr_command;
 475     cmd->io.opcode = TWE_OP_WRITE;
 476     cmd->io.size = 3;
 477     cmd->io.unit = unit;
 478     cmd->io.block_count = nblks;
 479     cmd->io.lba = lba;
 480
 481     error = twe_immediate_request(tr);
 482     if (error == 0)
 483         if (twe_report_request(tr))
 484             error = EIO;
 485     twe_release_request(tr);
 486     return(error);
 487 }
 488
 489 /********************************************************************************
 490  * Handle controller-specific control operations.
 491  */
 492 int
 493 twe_ioctl(struct twe_softc *sc, int cmd, void *addr)
 494 {
 495     struct twe_usercommand      *tu = (struct twe_usercommand *)addr;
 496     struct twe_paramcommand     *tp = (struct twe_paramcommand *)addr;
 497     struct twe_drivecommand     *td = (struct twe_drivecommand *)addr;
 498     union twe_statrequest       *ts = (union twe_statrequest *)addr;
 499     TWE_Param                   *param;
 500     void                        *data;
 501     unsigned short              *aen_code = (unsigned short *) addr;
 502     struct twe_request          *tr;
 503     u_int8_t                    srid;
 504     int                         error;
 505
 506     error = 0;
 507     switch(cmd) {
 508         /* handle a command from userspace */
 509     case TWEIO_COMMAND:
 510         /* get a request */
 511         while (twe_get_request(sc, &tr))
 512             tsleep(sc, 0, "twioctl", hz);
 513
 514         /*
 515          * Save the command's request ID, copy the user-supplied command in,
 516          * restore the request ID.
 517          */
 518         srid = tr->tr_command.generic.request_id;
 519         bcopy(&tu->tu_command, &tr->tr_command, sizeof(TWE_Command));
 520         tr->tr_command.generic.request_id = srid;
 521
 522         /*
 523          * if there's a data buffer, allocate and copy it in.
 524          * Must be in multipled of 512 bytes.
 525          */
 526         tr->tr_length = (tu->tu_size + 511) & ~511;
 527         if (tr->tr_length > 0) {
 528             tr->tr_data = kmalloc(tr->tr_length, M_DEVBUF, M_WAITOK);
 529             if ((error = copyin(tu->tu_data, tr->tr_data, tu->tu_size)) != 0)
 530                 goto cmd_done;
 531             tr->tr_flags |= TWE_CMD_DATAIN | TWE_CMD_DATAOUT;
 532         }
 533
 534         /* run the command */
 535         error = twe_wait_request(tr);
 536         if (error)
 537             goto cmd_done;
 538
 539         /* copy the command out again */
 540         bcopy(&tr->tr_command, &tu->tu_command, sizeof(TWE_Command));
 541
 542         /* if there was a data buffer, copy it out */
 543         if (tr->tr_length > 0)
 544             error = copyout(tr->tr_data, tu->tu_data, tu->tu_size);
 545
 546     cmd_done:
 547         /* free resources */
 548         if (tr->tr_data != NULL)
 549             kfree(tr->tr_data, M_DEVBUF);
 550         if (tr != NULL)
 551             twe_release_request(tr);
 552
 553         break;
 554
 555         /* fetch statistics counter */
 556     case TWEIO_STATS:
 557         switch (ts->ts_item) {
 558 #ifdef TWE_PERFORMANCE_MONITOR
 559         case TWEQ_FREE:
 560         case TWEQ_BIO:
 561         case TWEQ_READY:
 562         case TWEQ_BUSY:
 563         case TWEQ_COMPLETE:
 564             bcopy(&sc->twe_qstat[ts->ts_item], &ts->ts_qstat, sizeof(struct twe_qstat));
 565             break;
 566 #endif
 567         default:
 568             error = ENOENT;
 569             break;
 570         }
 571         break;
 572
 573         /* poll for an AEN */
 574     case TWEIO_AEN_POLL:
 575         *aen_code = twe_dequeue_aen(sc);
 576         break;
 577
 578         /* wait for another AEN to show up */
 579     case TWEIO_AEN_WAIT:
 580         crit_enter();
 581         while ((*aen_code = twe_dequeue_aen(sc)) == TWE_AEN_QUEUE_EMPTY) {
 582             error = tsleep(&sc->twe_aen_queue, PCATCH, "tweaen", 0);
 583             if (error == EINTR)
 584                 break;
 585         }
 586         crit_exit();
 587         break;
 588
 589     case TWEIO_GET_PARAM:
 590         if ((param = twe_get_param(sc, tp->tp_table_id, tp->tp_param_id, tp->tp_size, NULL)) == NULL) {
 591             twe_printf(sc, "TWEIO_GET_PARAM failed for 0x%x/0x%x/%d\n",
 592                        tp->tp_table_id, tp->tp_param_id, tp->tp_size);
 593             error = EINVAL;
 594         } else {
 595             if (param->parameter_size_bytes > tp->tp_size) {
 596                 twe_printf(sc, "TWEIO_GET_PARAM parameter too large (%d > %d)\n",
 597                            param->parameter_size_bytes, tp->tp_size);
 598                 error = EFAULT;
 599             } else {
 600                 error = copyout(param->data, tp->tp_data, param->parameter_size_bytes);
 601             }
 602             kfree(param, M_DEVBUF);
 603         }
 604         break;
 605
 606     case TWEIO_SET_PARAM:
 607         data = kmalloc(tp->tp_size, M_DEVBUF, M_WAITOK);
 608         error = copyin(tp->tp_data, data, tp->tp_size);
 609         if (error == 0)
 610             error = twe_set_param(sc, tp->tp_table_id, tp->tp_param_id, tp->tp_size, data);
 611         kfree(data, M_DEVBUF);
 612         break;
 613
 614     case TWEIO_RESET:
 615         twe_reset(sc);
 616         break;
 617
 618     case TWEIO_ADD_UNIT:
 619         error = twe_add_unit(sc, td->td_unit);
 620         break;
 621
 622     case TWEIO_DEL_UNIT:
 623         error = twe_del_unit(sc, td->td_unit);
 624         break;
 625
 626         /* XXX implement ATA PASSTHROUGH */
 627
 628         /* nothing we understand */
 629     default:
 630         error = ENOTTY;
 631     }
 632
 633     return(error);
 634 }
 635
 636 /********************************************************************************
 637  * Enable the useful interrupts from the controller.
 638  */
 639 void
 640 twe_enable_interrupts(struct twe_softc *sc)
 641 {
 642     sc->twe_state |= TWE_STATE_INTEN;
 643     TWE_CONTROL(sc,
 644                TWE_CONTROL_CLEAR_ATTENTION_INTERRUPT |
 645                TWE_CONTROL_UNMASK_RESPONSE_INTERRUPT |
 646                TWE_CONTROL_ENABLE_INTERRUPTS);
 647 }
 648
 649 /********************************************************************************
 650  * Disable interrupts from the controller.
 651  */
 652 void
 653 twe_disable_interrupts(struct twe_softc *sc)
 654 {
 655     TWE_CONTROL(sc, TWE_CONTROL_DISABLE_INTERRUPTS);
 656     sc->twe_state &= ~TWE_STATE_INTEN;
 657 }
 658
 659 /********************************************************************************
 660  ********************************************************************************
 661                                                                Command Submission
 662  ********************************************************************************
 663  ********************************************************************************/
 664
 665 /********************************************************************************
 666  * Read integer parameter table entries.
 667  */
 668 static int
 669 twe_get_param_1(struct twe_softc *sc, int table_id, int param_id, u_int8_t *result)
 670 {
 671     TWE_Param   *param;
 672
 673     if ((param = twe_get_param(sc, table_id, param_id, 1, NULL)) == NULL)
 674         return(ENOENT);
 675     *result = *(u_int8_t *)param->data;
 676     kfree(param, M_DEVBUF);
 677     return(0);
 678 }
 679
 680 static int
 681 twe_get_param_2(struct twe_softc *sc, int table_id, int param_id, u_int16_t *result)
 682 {
 683     TWE_Param   *param;
 684
 685     if ((param = twe_get_param(sc, table_id, param_id, 2, NULL)) == NULL)
 686         return(ENOENT);
 687     *result = *(u_int16_t *)param->data;
 688     kfree(param, M_DEVBUF);
 689     return(0);
 690 }
 691
 692 static int
 693 twe_get_param_4(struct twe_softc *sc, int table_id, int param_id, u_int32_t *result)
 694 {
 695     TWE_Param   *param;
 696
 697     if ((param = twe_get_param(sc, table_id, param_id, 4, NULL)) == NULL)
 698         return(ENOENT);
 699     *result = *(u_int32_t *)param->data;
 700     kfree(param, M_DEVBUF);
 701     return(0);
 702 }
 703
 704 /********************************************************************************
 705  * Perform a TWE_OP_GET_PARAM command.  If a callback function is provided, it
 706  * will be called with the command when it's completed.  If no callback is
 707  * provided, we will wait for the command to complete and then return just the data.
 708  * The caller is responsible for freeing the data when done with it.
 709  */
 710 static void *
 711 twe_get_param(struct twe_softc *sc, int table_id, int param_id, size_t param_size,
 712               void (* func)(struct twe_request *tr))
 713 {
 714     struct twe_request  *tr;
 715     TWE_Command         *cmd;
 716     TWE_Param           *param;
 717     int                 error;
 718
 719     debug_called(4);
 720
 721     tr = NULL;
 722     param = NULL;
 723
 724     /* get a command */
 725     if (twe_get_request(sc, &tr))
 726         goto err;
 727
 728     /* get a buffer */
 729     param = (TWE_Param *)kmalloc(TWE_SECTOR_SIZE, M_DEVBUF, M_INTWAIT);
 730     tr->tr_data = param;
 731     tr->tr_length = TWE_SECTOR_SIZE;
 732     tr->tr_flags = TWE_CMD_DATAIN | TWE_CMD_DATAOUT;
 733
 734     /* build the command for the controller */
 735     cmd = &tr->tr_command;
 736     cmd->param.opcode = TWE_OP_GET_PARAM;
 737     cmd->param.size = 2;
 738     cmd->param.unit = 0;
 739     cmd->param.param_count = 1;
 740
 741     /* fill in the outbound parameter data */
 742     param->table_id = table_id;
 743     param->parameter_id = param_id;
 744     param->parameter_size_bytes = param_size;
 745
 746     /* submit the command and either wait or let the callback handle it */
 747     if (func == NULL) {
 748         /* XXX could use twe_wait_request here if interrupts were enabled? */
 749         error = twe_immediate_request(tr);
 750         if (error == 0) {
 751             if (twe_report_request(tr))
 752                 goto err;
 753         }
 754         else
 755                 goto err;
 756         twe_release_request(tr);
 757         return(param);
 758     } else {
 759         tr->tr_complete = func;
 760         error = twe_map_request(tr);
 761         if ((error == 0) || (error == EBUSY))
 762             return(func);
 763     }
 764
 765     /* something failed */
 766 err:
 767     debug(1, "failed");
 768     if (tr != NULL)
 769         twe_release_request(tr);
 770     if (param != NULL)
 771         kfree(param, M_DEVBUF);
 772     return(NULL);
 773 }
 774
 775 /********************************************************************************
 776  * Set integer parameter table entries.
 777  */
 778 #ifdef TWE_SHUTDOWN_NOTIFICATION
 779 static int
 780 twe_set_param_1(struct twe_softc *sc, int table_id, int param_id, u_int8_t value)
 781 {
 782     return(twe_set_param(sc, table_id, param_id, sizeof(value), &value));
 783 }
 784 #endif
 785
 786 #if 0
 787 static int
 788 twe_set_param_2(struct twe_softc *sc, int table_id, int param_id, u_int16_t value)
 789 {
 790     return(twe_set_param(sc, table_id, param_id, sizeof(value), &value));
 791 }
 792
 793 static int
 794 twe_set_param_4(struct twe_softc *sc, int table_id, int param_id, u_int32_t value)
 795 {
 796     return(twe_set_param(sc, table_id, param_id, sizeof(value), &value));
 797 }
 798 #endif
 799
 800 /********************************************************************************
 801  * Perform a TWE_OP_SET_PARAM command, returns nonzero on error.
 802  */
 803 static int
 804 twe_set_param(struct twe_softc *sc, int table_id, int param_id, int param_size, void *data)
 805 {
 806     struct twe_request  *tr;
 807     TWE_Command         *cmd;
 808     TWE_Param           *param;
 809     int                 error;
 810
 811     debug_called(4);
 812
 813     tr = NULL;
 814     param = NULL;
 815     error = ENOMEM;
 816
 817     /* get a command */
 818     if (twe_get_request(sc, &tr))
 819         goto out;
 820
 821     /* get a buffer */
 822     param = (TWE_Param *)kmalloc(TWE_SECTOR_SIZE, M_DEVBUF, M_INTWAIT);
 823     tr->tr_data = param;
 824     tr->tr_length = TWE_SECTOR_SIZE;
 825     tr->tr_flags = TWE_CMD_DATAIN | TWE_CMD_DATAOUT;
 826
 827     /* build the command for the controller */
 828     cmd = &tr->tr_command;
 829     cmd->param.opcode = TWE_OP_SET_PARAM;
 830     cmd->param.size = 2;
 831     cmd->param.unit = 0;
 832     cmd->param.param_count = 1;
 833
 834     /* fill in the outbound parameter data */
 835     param->table_id = table_id;
 836     param->parameter_id = param_id;
 837     param->parameter_size_bytes = param_size;
 838     bcopy(data, param->data, param_size);
 839
 840     /* XXX could use twe_wait_request here if interrupts were enabled? */
 841     error = twe_immediate_request(tr);
 842     if (error == 0) {
 843         if (twe_report_request(tr))
 844             error = EIO;
 845     }
 846
 847 out:
 848     if (tr != NULL)
 849         twe_release_request(tr);
 850     if (param != NULL)
 851         kfree(param, M_DEVBUF);
 852     return(error);
 853 }
 854
 855 /********************************************************************************
 856  * Perform a TWE_OP_INIT_CONNECTION command, returns nonzero on error.
 857  *
 858  * Typically called with interrupts disabled.
 859  */
 860 static int
 861 twe_init_connection(struct twe_softc *sc, int mode)
 862 {
 863     struct twe_request  *tr;
 864     TWE_Command         *cmd;
 865     int                 error;
 866
 867     debug_called(4);
 868
 869     /* get a command */
 870     if (twe_get_request(sc, &tr))
 871         return(NULL);
 872
 873     /* build the command */
 874     cmd = &tr->tr_command;
 875     cmd->initconnection.opcode = TWE_OP_INIT_CONNECTION;
 876     cmd->initconnection.size = 3;
 877     cmd->initconnection.host_id = 0;
 878     cmd->initconnection.message_credits = mode;
 879     cmd->initconnection.response_queue_pointer = 0;
 880
 881     /* submit the command */
 882     error = twe_immediate_request(tr);
 883     twe_release_request(tr);
 884
 885     if (mode == TWE_INIT_MESSAGE_CREDITS)
 886         sc->twe_host_id = cmd->initconnection.host_id;
 887     return(error);
 888 }
 889
 890 /********************************************************************************
 891  * Start the command (tr) and sleep waiting for it to complete.
 892  *
 893  * Successfully completed commands are dequeued.
 894  */
 895 static int
 896 twe_wait_request(struct twe_request *tr)
 897 {
 898     debug_called(4);
 899
 900     tr->tr_flags |= TWE_CMD_SLEEPER;
 901     tr->tr_status = TWE_CMD_BUSY;
 902     twe_enqueue_ready(tr);
 903     twe_startio(tr->tr_sc);
 904     crit_enter();
 905     while (tr->tr_status == TWE_CMD_BUSY)
 906         tsleep(tr, 0, "twewait", 0);
 907     crit_exit();
 908
 909     return(tr->tr_status != TWE_CMD_COMPLETE);
 910 }
 911
 912 /********************************************************************************
 913  * Start the command (tr) and busy-wait for it to complete.
 914  * This should only be used when interrupts are actually disabled (although it
 915  * will work if they are not).
 916  */
 917 static int
 918 twe_immediate_request(struct twe_request *tr)
 919 {
 920     int         error;
 921
 922     debug_called(4);
 923
 924     tr->tr_status = TWE_CMD_BUSY;
 925     if ((error = twe_map_request(tr)) != 0)
 926         if (error != EBUSY)
 927             return(error);
 928     while (tr->tr_status == TWE_CMD_BUSY){
 929         twe_done(tr->tr_sc);
 930     }
 931     return(tr->tr_status != TWE_CMD_COMPLETE);
 932 }
 933
 934 /********************************************************************************
 935  * Handle completion of an I/O command.
 936  */
 937 static void
 938 twe_completeio(struct twe_request *tr)
 939 {
 940     struct twe_softc    *sc = tr->tr_sc;
 941     struct bio          *bio = (twe_bio *)tr->tr_private;
 942     struct buf          *bp = bio->bio_buf;
 943
 944     debug_called(4);
 945
 946     if (tr->tr_status == TWE_CMD_COMPLETE) {
 947         if (tr->tr_command.generic.status)
 948                 if (twe_report_request(tr)) {
 949                         bp->b_error = EIO;
 950                         bp->b_flags |= B_ERROR;
 951                 }
 952     } else {
 953         twe_panic(sc, "twe_completeio on incomplete command");
 954     }
 955     tr->tr_private = NULL;
 956     twed_intr(bio);
 957     twe_release_request(tr);
 958 }
 959
 960 /********************************************************************************
 961  * Reset the controller and pull all the active commands back onto the ready
 962  * queue.  Used to restart a controller that's exhibiting bad behaviour.
 963  */
 964 static void
 965 twe_reset(struct twe_softc *sc)
 966 {
 967     struct twe_request  *tr;
 968     int                 i;
 969
 970     /*
 971      * Sleep for a short period to allow AENs to be signalled.
 972      */
 973     tsleep(sc, 0, "twereset", hz);
 974
 975     /*
 976      * Disable interrupts from the controller, and mask any accidental entry
 977      * into our interrupt handler.
 978      */
 979     twe_printf(sc, "controller reset in progress...\n");
 980     twe_disable_interrupts(sc);
 981     crit_enter();
 982
 983     /*
 984      * Try to soft-reset the controller.
 985      */
 986     for (i = 0; i < TWE_MAX_RESET_TRIES; i++) {
 987
 988         if (i > 0)
 989             twe_printf(sc, "reset %d failed, trying again\n", i);
 990
 991         if (!twe_soft_reset(sc))
 992             break;                      /* reset process complete */
 993     }
 994     /* did we give up? */
 995     if (i >= TWE_MAX_RESET_TRIES) {
 996         twe_printf(sc, "can't reset controller, giving up\n");
 997         goto out;
 998     }
 999
1000     /*
1001      * Move all of the commands that were busy back to the ready queue.
1002      */
1003     i = 0;
1004     while ((tr = twe_dequeue_busy(sc)) != NULL) {
1005         twe_enqueue_ready(tr);
1006         i++;
1007     }
1008
1009     /*
1010      * Kick the controller to start things going again, then re-enable interrupts.
1011      */
1012     twe_startio(sc);
1013     twe_enable_interrupts(sc);
1014     twe_printf(sc, "controller reset done, %d commands restarted\n", i);
1015
1016 out:
1017     crit_exit();
1018     twe_enable_interrupts(sc);
1019 }
1020
1021 /********************************************************************************
1022  ********************************************************************************
1023                                                         Command I/O to Controller
1024  ********************************************************************************
1025  ********************************************************************************/
1026
1027 /********************************************************************************
1028  * Try to deliver (tr) to the controller.
1029  *
1030  * Can be called at any interrupt level, with or without interrupts enabled.
1031  */
1032 int
1033 twe_start(struct twe_request *tr)
1034 {
1035     struct twe_softc    *sc = tr->tr_sc;
1036     int                 i, done;
1037     u_int32_t           status_reg;
1038
1039     debug_called(4);
1040
1041     /* mark the command as currently being processed */
1042     tr->tr_status = TWE_CMD_BUSY;
1043
1044     /*
1045      * Spin briefly waiting for the controller to come ready
1046      *
1047      * XXX it might be more efficient to return EBUSY immediately
1048      *     and let the command be rescheduled.
1049      */
1050     for (i = 100000, done = 0; (i > 0) && !done; i--) {
1051         crit_enter();
1052
1053         /* check to see if we can post a command */
1054         status_reg = TWE_STATUS(sc);
1055         twe_check_bits(sc, status_reg);
1056
1057         if (!(status_reg & TWE_STATUS_COMMAND_QUEUE_FULL)) {
1058             /* move command to work queue */
1059             twe_enqueue_busy(tr);
1060             TWE_COMMAND_QUEUE(sc, tr->tr_cmdphys);
1061             done = 1;
1062 #ifdef TWE_DEBUG
1063             if (tr->tr_complete != NULL) {
1064                 debug(3, "queued request %d with callback %p", tr->tr_command.generic.request_id, tr->tr_complete);
1065             } else if (tr->tr_flags & TWE_CMD_SLEEPER) {
1066                 debug(3, "queued request %d with wait channel %p", tr->tr_command.generic.request_id, tr);
1067             } else {
1068                 debug(3, "queued request %d for polling caller", tr->tr_command.generic.request_id);
1069             }
1070 #endif
1071         }
1072         crit_exit();    /* drop critical section to allow completion interrupts */
1073     }
1074
1075     /* command is enqueued */
1076     if (done)
1077         return(0);
1078
1079     /*
1080      * We couldn't get the controller to take the command; try submitting it again later.
1081      * This should only happen if something is wrong with the controller, or if we have
1082      * overestimated the number of commands it can accept.  (Should we actually reject
1083      * the command at this point?)
1084      */
1085     return(EBUSY);
1086 }
1087
1088 /********************************************************************************
1089  * Poll the controller (sc) for completed commands.
1090  *
1091  * Can be called at any interrupt level, with or without interrupts enabled.
1092  */
1093 static void
1094 twe_done(struct twe_softc *sc)
1095 {
1096     TWE_Response_Queue  rq;
1097     struct twe_request  *tr;
1098     int                 found;
1099     u_int32_t           status_reg;
1100
1101     debug_called(5);
1102
1103     /* loop collecting completed commands */
1104     found = 0;
1105     crit_enter();
1106     for (;;) {
1107         status_reg = TWE_STATUS(sc);
1108         twe_check_bits(sc, status_reg);         /* XXX should this fail? */
1109
1110         if (!(status_reg & TWE_STATUS_RESPONSE_QUEUE_EMPTY)) {
1111             found = 1;
1112             rq = TWE_RESPONSE_QUEUE(sc);
1113             tr = sc->twe_lookup[rq.u.response_id];      /* find command */
1114             if (tr->tr_status != TWE_CMD_BUSY)
1115                 twe_printf(sc, "completion event for nonbusy command\n");
1116             tr->tr_status = TWE_CMD_COMPLETE;
1117             debug(3, "completed request id %d with status %d",
1118                   tr->tr_command.generic.request_id, tr->tr_command.generic.status);
1119             /* move to completed queue */
1120             twe_remove_busy(tr);
1121             twe_enqueue_complete(tr);
1122             sc->twe_state &= ~TWE_STATE_CTLR_BUSY;
1123         } else {
1124             break;                                      /* no response ready */
1125         }
1126     }
1127     crit_exit();
1128
1129     /* if we've completed any commands, try posting some more */
1130     if (found)
1131         twe_startio(sc);
1132
1133     /* handle completion and timeouts */
1134     twe_complete(sc);           /* XXX use deferred completion? */
1135 }
1136
1137 /********************************************************************************
1138  * Perform post-completion processing for commands on (sc).
1139  *
1140  * This is split from twe_done as it can be safely deferred and run at a lower
1141  * priority level should facilities for such a thing become available.
1142  */
1143 static void
1144 twe_complete(struct twe_softc *sc)
1145 {
1146     struct twe_request  *tr;
1147
1148     debug_called(5);
1149
1150     /*
1151      * Pull commands off the completed list, dispatch them appropriately
1152      */
1153     while ((tr = twe_dequeue_complete(sc)) != NULL) {
1154
1155         /* unmap the command's data buffer */
1156         twe_unmap_request(tr);
1157
1158         /* dispatch to suit command originator */
1159         if (tr->tr_complete != NULL) {          /* completion callback */
1160             debug(2, "call completion handler %p", tr->tr_complete);
1161             tr->tr_complete(tr);
1162
1163         } else if (tr->tr_flags & TWE_CMD_SLEEPER) {    /* caller is asleep waiting */
1164             debug(2, "wake up command owner on %p", tr);
1165             wakeup_one(tr);
1166
1167         } else {                                        /* caller is polling command */
1168             debug(2, "command left for owner");
1169         }
1170     }
1171 }
1172
1173 /********************************************************************************
1174  * Wait for (status) to be set in the controller status register for up to
1175  * (timeout) seconds.  Returns 0 if found, nonzero if we time out.
1176  *
1177  * Note: this busy-waits, rather than sleeping, since we may be called with
1178  * eg. clock interrupts masked.
1179  */
1180 static int
1181 twe_wait_status(struct twe_softc *sc, u_int32_t status, int timeout)
1182 {
1183     time_t      expiry;
1184     u_int32_t   status_reg;
1185
1186     debug_called(4);
1187
1188     expiry = time_second + timeout;
1189
1190     do {
1191         status_reg = TWE_STATUS(sc);
1192         if (status_reg & status)        /* got the required bit(s)? */
1193             return(0);
1194         DELAY(100000);
1195     } while (time_second <= expiry);
1196
1197     return(1);
1198 }
1199
1200 /********************************************************************************
1201  * Drain the response queue, which may contain responses to commands we know
1202  * nothing about.
1203  */
1204 static int
1205 twe_drain_response_queue(struct twe_softc *sc)
1206 {
1207     TWE_Response_Queue  rq;
1208     u_int32_t           status_reg;
1209
1210     debug_called(4);
1211
1212     for (;;) {                          /* XXX give up eventually? */
1213         status_reg = TWE_STATUS(sc);
1214         if (twe_check_bits(sc, status_reg))
1215             return(1);
1216         if (status_reg & TWE_STATUS_RESPONSE_QUEUE_EMPTY)
1217             return(0);
1218         rq = TWE_RESPONSE_QUEUE(sc);
1219     }
1220 }
1221
1222 /********************************************************************************
1223  * Soft-reset the controller
1224  */
1225 static int
1226 twe_soft_reset(struct twe_softc *sc)
1227 {
1228     u_int32_t           status_reg;
1229
1230     debug_called(2);
1231
1232     TWE_SOFT_RESET(sc);
1233
1234     if (twe_wait_status(sc, TWE_STATUS_ATTENTION_INTERRUPT, 30)) {
1235         twe_printf(sc, "no attention interrupt\n");
1236         return(1);
1237     }
1238     TWE_CONTROL(sc, TWE_CONTROL_CLEAR_ATTENTION_INTERRUPT);
1239     if (twe_drain_aen_queue(sc)) {
1240         twe_printf(sc, "can't drain AEN queue\n");
1241         return(1);
1242     }
1243     if (twe_find_aen(sc, TWE_AEN_SOFT_RESET)) {
1244         twe_printf(sc, "reset not reported\n");
1245         return(1);
1246     }
1247     status_reg = TWE_STATUS(sc);
1248     if (TWE_STATUS_ERRORS(status_reg) || twe_check_bits(sc, status_reg)) {
1249         twe_printf(sc, "controller errors detected\n");
1250         return(1);
1251     }
1252     if (twe_drain_response_queue(sc)) {
1253         twe_printf(sc, "can't drain response queue\n");
1254         return(1);
1255     }
1256     return(0);
1257 }
1258
1259 /********************************************************************************
1260  ********************************************************************************
1261                                                                Interrupt Handling
1262  ********************************************************************************
1263  ********************************************************************************/
1264
1265 /********************************************************************************
1266  * Host interrupt.
1267  *
1268  * XXX what does this mean?
1269  */
1270 static void
1271 twe_host_intr(struct twe_softc *sc)
1272 {
1273     debug_called(4);
1274
1275     twe_printf(sc, "host interrupt\n");
1276     TWE_CONTROL(sc, TWE_CONTROL_CLEAR_HOST_INTERRUPT);
1277 }
1278
1279 /********************************************************************************
1280  * Attention interrupt.
1281  *
1282  * Signalled when the controller has one or more AENs for us.
1283  */
1284 static void
1285 twe_attention_intr(struct twe_softc *sc)
1286 {
1287     debug_called(4);
1288
1289     /* instigate a poll for AENs */
1290     if (twe_fetch_aen(sc)) {
1291         twe_printf(sc, "error polling for signalled AEN\n");
1292     } else {
1293         TWE_CONTROL(sc, TWE_CONTROL_CLEAR_ATTENTION_INTERRUPT);
1294     }
1295 }
1296
1297 /********************************************************************************
1298  * Command interrupt.
1299  *
1300  * Signalled when the controller can handle more commands.
1301  */
1302 static void
1303 twe_command_intr(struct twe_softc *sc)
1304 {
1305     debug_called(4);
1306
1307     /*
1308      * We don't use this, rather we try to submit commands when we receive
1309      * them, and when other commands have completed.  Mask it so we don't get
1310      * another one.
1311     twe_printf(sc, "command interrupt\n");
1312      */
1313     TWE_CONTROL(sc, TWE_CONTROL_MASK_COMMAND_INTERRUPT);
1314 }
1315
1316 /********************************************************************************
1317  ********************************************************************************
1318                                                       Asynchronous Event Handling
1319  ********************************************************************************
1320  ********************************************************************************/
1321
1322 /********************************************************************************
1323  * Request an AEN from the controller.
1324  */
1325 static int
1326 twe_fetch_aen(struct twe_softc *sc)
1327 {
1328
1329     debug_called(4);
1330
1331     if ((twe_get_param(sc, TWE_PARAM_AEN, TWE_PARAM_AEN_UnitCode, 2, twe_handle_aen)) == NULL)
1332         return(EIO);
1333     return(0);
1334 }
1335
1336 /********************************************************************************
1337  * Handle an AEN returned by the controller.
1338  */
1339 static void
1340 twe_handle_aen(struct twe_request *tr)
1341 {
1342     struct twe_softc    *sc = tr->tr_sc;
1343     TWE_Param           *param;
1344     u_int16_t           aen;
1345
1346     debug_called(4);
1347
1348     /* XXX check for command success somehow? */
1349
1350     param = (TWE_Param *)tr->tr_data;
1351     aen = *(u_int16_t *)(param->data);
1352
1353     kfree(tr->tr_data, M_DEVBUF);
1354     twe_release_request(tr);
1355     twe_enqueue_aen(sc, aen);
1356
1357     /* XXX poll for more AENs? */
1358 }
1359
1360 /********************************************************************************
1361  * Pull AENs out of the controller and park them in the queue, in a context where
1362  * interrupts aren't active.  Return nonzero if we encounter any errors in the
1363  * process of obtaining all the available AENs.
1364  */
1365 static int
1366 twe_drain_aen_queue(struct twe_softc *sc)
1367 {
1368     u_int16_t   aen;
1369
1370     for (;;) {
1371         if (twe_get_param_2(sc, TWE_PARAM_AEN, TWE_PARAM_AEN_UnitCode, &aen))
1372             return(1);
1373         if (aen == TWE_AEN_QUEUE_EMPTY)
1374             return(0);
1375         twe_enqueue_aen(sc, aen);
1376     }
1377 }
1378
1379 /********************************************************************************
1380  * Push an AEN that we've received onto the queue.
1381  *
1382  * Note that we have to lock this against reentrance, since it may be called
1383  * from both interrupt and non-interrupt context.
1384  *
1385  * If someone is waiting for the AEN we have, wake them up.
1386  */
1387 static void
1388 twe_enqueue_aen(struct twe_softc *sc, u_int16_t aen)
1389 {
1390     char        *msg;
1391     int         next, nextnext;
1392
1393     debug_called(4);
1394
1395     if ((msg = twe_format_aen(sc, aen)) != NULL)
1396         twe_printf(sc, "AEN: <%s>\n", msg);
1397
1398     crit_enter();
1399     /* enqueue the AEN */
1400     next = ((sc->twe_aen_head + 1) % TWE_Q_LENGTH);
1401     nextnext = ((sc->twe_aen_head + 2) % TWE_Q_LENGTH);
1402
1403     /* check to see if this is the last free slot, and subvert the AEN if it is */
1404     if (nextnext == sc->twe_aen_tail)
1405         aen = TWE_AEN_QUEUE_FULL;
1406
1407     /* look to see if there's room for this AEN */
1408     if (next != sc->twe_aen_tail) {
1409         sc->twe_aen_queue[sc->twe_aen_head] = aen;
1410         sc->twe_aen_head = next;
1411     }
1412
1413     /* wake up anyone asleep on the queue */
1414     wakeup(&sc->twe_aen_queue);
1415
1416     /* anyone looking for this AEN? */
1417     if (sc->twe_wait_aen == aen) {
1418         sc->twe_wait_aen = -1;
1419         wakeup(&sc->twe_wait_aen);
1420     }
1421     crit_exit();
1422 }
1423
1424 /********************************************************************************
1425  * Pop an AEN off the queue, or return -1 if there are none left.
1426  *
1427  * We are more or less interrupt-safe, so don't block interrupts.
1428  */
1429 static u_int16_t
1430 twe_dequeue_aen(struct twe_softc *sc)
1431 {
1432     u_int16_t   result;
1433
1434     debug_called(4);
1435
1436     if (sc->twe_aen_tail == sc->twe_aen_head) {
1437         result = TWE_AEN_QUEUE_EMPTY;
1438     } else {
1439         result = sc->twe_aen_queue[sc->twe_aen_tail];
1440         sc->twe_aen_tail = ((sc->twe_aen_tail + 1) % TWE_Q_LENGTH);
1441     }
1442     return(result);
1443 }
1444
1445 /********************************************************************************
1446  * Check to see if the requested AEN is in the queue.
1447  *
1448  * XXX we could probably avoid masking interrupts here
1449  */
1450 static int
1451 twe_find_aen(struct twe_softc *sc, u_int16_t aen)
1452 {
1453     int         i, missing;
1454
1455     missing = 1;
1456     crit_enter();
1457     for (i = sc->twe_aen_tail; (i != sc->twe_aen_head) && missing; i = (i + 1) % TWE_Q_LENGTH) {
1458         if (sc->twe_aen_queue[i] == aen)
1459             missing = 0;
1460     }
1461     crit_exit();
1462     return(missing);
1463 }
1464
1465
1466 #if 0   /* currently unused */
1467 /********************************************************************************
1468  * Sleep waiting for at least (timeout) seconds until we see (aen) as
1469  * requested.  Returns nonzero on timeout or failure.
1470  *
1471  * XXX: this should not be used in cases where there may be more than one sleeper
1472  *      without a mechanism for registering multiple sleepers.
1473  */
1474 static int
1475 twe_wait_aen(struct twe_softc *sc, int aen, int timeout)
1476 {
1477     time_t      expiry;
1478     int         found;
1479
1480     debug_called(4);
1481
1482     expiry = time_second + timeout;
1483     found = 0;
1484
1485     crit_enter();
1486     sc->twe_wait_aen = aen;
1487     do {
1488         twe_fetch_aen(sc);
1489         tsleep(&sc->twe_wait_aen, PZERO, "twewaen", hz);
1490         if (sc->twe_wait_aen == -1)
1491             found = 1;
1492     } while ((time_second <= expiry) && !found);
1493     crit_exit();
1494     return(!found);
1495 }
1496 #endif
1497
1498 /********************************************************************************
1499  ********************************************************************************
1500                                                         Command Buffer Management
1501  ********************************************************************************
1502  ********************************************************************************/
1503
1504 /********************************************************************************
1505  * Get a new command buffer.
1506  *
1507  * This will return NULL if all command buffers are in use.
1508  */
1509 static int
1510 twe_get_request(struct twe_softc *sc, struct twe_request **tr)
1511 {
1512     debug_called(4);
1513
1514     /* try to reuse an old buffer */
1515     *tr = twe_dequeue_free(sc);
1516
1517     /* initialise some fields to their defaults */
1518     if (*tr != NULL) {
1519         (*tr)->tr_data = NULL;
1520         (*tr)->tr_private = NULL;
1521         (*tr)->tr_status = TWE_CMD_SETUP;               /* command is in setup phase */
1522         (*tr)->tr_flags = 0;
1523         (*tr)->tr_complete = NULL;
1524         (*tr)->tr_command.generic.status = 0;           /* before submission to controller */
1525         (*tr)->tr_command.generic.flags = 0;            /* not used */
1526     }
1527     return(*tr == NULL);
1528 }
1529
1530 /********************************************************************************
1531  * Release a command buffer for reuse.
1532  *
1533  */
1534 static void
1535 twe_release_request(struct twe_request *tr)
1536 {
1537     debug_called(4);
1538
1539     if (tr->tr_private != NULL)
1540         twe_panic(tr->tr_sc, "tr_private != NULL");
1541     twe_enqueue_free(tr);
1542 }
1543
1544 /********************************************************************************
1545  ********************************************************************************
1546                                                                         Debugging
1547  ********************************************************************************
1548  ********************************************************************************/
1549
1550 /********************************************************************************
1551  * Print some information about the controller
1552  */
1553 void
1554 twe_describe_controller(struct twe_softc *sc)
1555 {
1556     TWE_Param           *p[6];
1557     u_int8_t            ports;
1558     u_int32_t           size;
1559     int                 i;
1560
1561     debug_called(2);
1562
1563     /* get the port count */
1564     twe_get_param_1(sc, TWE_PARAM_CONTROLLER, TWE_PARAM_CONTROLLER_PortCount, &ports);
1565
1566     /* get version strings */
1567     p[0] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_FW,   16, NULL);
1568     p[1] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_BIOS, 16, NULL);
1569
1570     if (p[0] && p[1])
1571             twe_printf(sc, "%d ports, Firmware %.16s, BIOS %.16s\n", ports, p[0]->data, p[1]->data);
1572     if (bootverbose) {
1573         p[2] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_Mon,  16, NULL);
1574         p[3] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_PCB,  8, NULL);
1575         p[4] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_ATA,  8, NULL);
1576         p[5] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_PCI,  8, NULL);
1577
1578         if (p[2] && p[3] && p[4] && p[5])
1579                 twe_printf(sc, "Monitor %.16s, PCB %.8s, Achip %.8s, Pchip %.8s\n",
1580                         p[2]->data, p[3]->data, p[4]->data, p[5]->data);
1581
1582         if (p[2])
1583                 kfree(p[2], M_DEVBUF);
1584         if (p[3])
1585                 kfree(p[3], M_DEVBUF);
1586         if (p[4])
1587                 kfree(p[4], M_DEVBUF);
1588         if (p[5])
1589                 kfree(p[5], M_DEVBUF);
1590     }
1591     if (p[0])
1592         kfree(p[0], M_DEVBUF);
1593     if (p[1])
1594         kfree(p[1], M_DEVBUF);
1595
1596     /* print attached drives */
1597     if (bootverbose) {
1598         p[0] = twe_get_param(sc, TWE_PARAM_DRIVESUMMARY, TWE_PARAM_DRIVESUMMARY_Status, 16, NULL);
1599         for (i = 0; i < ports; i++) {
1600             if (p[0]->data[i] != TWE_PARAM_DRIVESTATUS_Present)
1601                 continue;
1602             twe_get_param_4(sc, TWE_PARAM_DRIVEINFO + i, TWE_PARAM_DRIVEINFO_Size, &size);
1603             p[1] = twe_get_param(sc, TWE_PARAM_DRIVEINFO + i, TWE_PARAM_DRIVEINFO_Model, 40, NULL);
1604             if (p[1] != NULL) {
1605                 twe_printf(sc, "port %d: %.40s %dMB\n", i, p[1]->data, size / 2048);
1606                 kfree(p[1], M_DEVBUF);
1607             } else {
1608                 twe_printf(sc, "port %d, drive status unavailable\n", i);
1609             }
1610         }
1611         if (p[0])
1612             kfree(p[0], M_DEVBUF);
1613     }
1614 }
1615
1616
1617 /********************************************************************************
1618  * Look up a text description of a numeric code and return a pointer to same.
1619  */
1620 char *
1621 twe_describe_code(struct twe_code_lookup *table, u_int32_t code)
1622 {
1623     int         i;
1624
1625     for (i = 0; table[i].string != NULL; i++)
1626         if (table[i].code == code)
1627             return(table[i].string);
1628     return(table[i+1].string);
1629 }
1630
1631
1632 /********************************************************************************
1633  * Complain if the status bits aren't what we're expecting.
1634  *
1635  * Rate-limit the complaints to at most one of each every five seconds, but
1636  * always return the correct status.
1637  */
1638 static int
1639 twe_check_bits(struct twe_softc *sc, u_int32_t status_reg)
1640 {
1641     int                 result;
1642     static time_t       lastwarn[2] = {0, 0};
1643
1644     /*
1645      * This can be a little problematic, as twe_panic may call twe_reset if
1646      * TWE_DEBUG is not set, which will call us again as part of the soft reset.
1647      */
1648     if ((status_reg & TWE_STATUS_PANIC_BITS) != 0) {
1649         twe_printf(sc, "FATAL STATUS BIT(S) %b\n", status_reg & TWE_STATUS_PANIC_BITS,
1650                    TWE_STATUS_BITS_DESCRIPTION);
1651         twe_panic(sc, "fatal status bits");
1652     }
1653
1654     result = 0;
1655     if ((status_reg & TWE_STATUS_EXPECTED_BITS) != TWE_STATUS_EXPECTED_BITS) {
1656         if (time_second > (lastwarn[0] + 5)) {
1657             twe_printf(sc, "missing expected status bit(s) %b\n", ~status_reg & TWE_STATUS_EXPECTED_BITS,
1658                        TWE_STATUS_BITS_DESCRIPTION);
1659             lastwarn[0] = time_second;
1660         }
1661         result = 1;
1662     }
1663
1664     if ((status_reg & TWE_STATUS_UNEXPECTED_BITS) != 0) {
1665         if (time_second > (lastwarn[1] + 5)) {
1666             twe_printf(sc, "unexpected status bit(s) %b\n", status_reg & TWE_STATUS_UNEXPECTED_BITS,
1667                        TWE_STATUS_BITS_DESCRIPTION);
1668             lastwarn[1] = time_second;
1669         }
1670         result = 1;
1671         if (status_reg & TWE_STATUS_PCI_PARITY_ERROR) {
1672             twe_printf(sc, "PCI parity error: Reseat card, move card or buggy device present.");
1673             twe_clear_pci_parity_error(sc);
1674         }
1675         if (status_reg & TWE_STATUS_PCI_ABORT) {
1676             twe_printf(sc, "PCI abort, clearing.");
1677             twe_clear_pci_abort(sc);
1678         }
1679     }
1680
1681     return(result);
1682 }
1683
1684 /********************************************************************************
1685  * Return a string describing (aen).
1686  *
1687  * The low 8 bits of the aen are the code, the high 8 bits give the unit number
1688  * where an AEN is specific to a unit.
1689  *
1690  * Note that we could expand this routine to handle eg. up/downgrading the status
1691  * of a drive if we had some idea of what the drive's initial status was.
1692  */
1693
1694 static char *
1695 twe_format_aen(struct twe_softc *sc, u_int16_t aen)
1696 {
1697     static char buf[80];
1698     device_t    child;
1699     char        *code, *msg;
1700
1701     code = twe_describe_code(twe_table_aen, TWE_AEN_CODE(aen));
1702     msg = code + 2;
1703
1704     switch (*code) {
1705     case 'q':
1706         if (!bootverbose)
1707             return(NULL);
1708         /* FALLTHROUGH */
1709     case 'a':
1710         return(msg);
1711
1712     case 'c':
1713         if ((child = sc->twe_drive[TWE_AEN_UNIT(aen)].td_disk) != NULL) {
1714             ksprintf(buf, "twed%d: %s", device_get_unit(child), msg);
1715         } else {
1716             ksprintf(buf, "twe%d: %s for unknown unit %d", device_get_unit(sc->twe_dev),
1717                     msg, TWE_AEN_UNIT(aen));
1718         }
1719         return(buf);
1720
1721     case 'p':
1722         ksprintf(buf, "twe%d: port %d: %s", device_get_unit(sc->twe_dev), TWE_AEN_UNIT(aen),
1723                 msg);
1724         return(buf);
1725
1726
1727     case 'x':
1728     default:
1729         break;
1730     }
1731     ksprintf(buf, "unknown AEN 0x%x", aen);
1732     return(buf);
1733 }
1734
1735 /********************************************************************************
1736  * Print a diagnostic if the status of the command warrants it, and return
1737  * either zero (command was ok) or nonzero (command failed).
1738  */
1739 static int
1740 twe_report_request(struct twe_request *tr)
1741 {
1742     struct twe_softc    *sc = tr->tr_sc;
1743     TWE_Command         *cmd = &tr->tr_command;
1744     int                 result = 0;
1745
1746     /*
1747      * Check the command status value and handle accordingly.
1748      */
1749     if (cmd->generic.status == TWE_STATUS_RESET) {
1750         /*
1751          * The status code 0xff requests a controller reset.
1752          */
1753         twe_printf(sc, "command returned with controller reset request\n");
1754         twe_reset(sc);
1755         result = 1;
1756     } else if (cmd->generic.status > TWE_STATUS_FATAL) {
1757         /*
1758          * Fatal errors that don't require controller reset.
1759          *
1760          * We know a few special flags values.
1761          */
1762         switch (cmd->generic.flags) {
1763         case 0x1b:
1764             device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1765                           "drive timeout");
1766             break;
1767         case 0x51:
1768             device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1769                           "unrecoverable drive error");
1770             break;
1771         default:
1772             device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1773                           "controller error - %s (flags = 0x%x)\n",
1774                           twe_describe_code(twe_table_status, cmd->generic.status),
1775                           cmd->generic.flags);
1776             result = 1;
1777         }
1778     } else if (cmd->generic.status > TWE_STATUS_WARNING) {
1779         /*
1780          * Warning level status.
1781          */
1782         device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1783                       "warning - %s (flags = 0x%x)\n",
1784                       twe_describe_code(twe_table_status, cmd->generic.status),
1785                       cmd->generic.flags);
1786     } else if (cmd->generic.status > 0x40) {
1787         /*
1788          * Info level status.
1789          */
1790         device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1791                       "attention - %s (flags = 0x%x)\n",
1792                       twe_describe_code(twe_table_status, cmd->generic.status),
1793                       cmd->generic.flags);
1794     }
1795
1796     return(result);
1797 }
1798
1799 /********************************************************************************
1800  * Print some controller state to aid in debugging error/panic conditions
1801  */
1802 void
1803 twe_print_controller(struct twe_softc *sc)
1804 {
1805     u_int32_t           status_reg;
1806
1807     status_reg = TWE_STATUS(sc);
1808     twe_printf(sc, "status   %b\n", status_reg, TWE_STATUS_BITS_DESCRIPTION);
1809     twe_printf(sc, "          current  max    min\n");
1810     twe_printf(sc, "free      %04d     %04d   %04d\n", sc->twe_qstat[TWEQ_FREE].q_length, sc->twe_qstat[TWEQ_FREE].q_max, sc->twe_qstat[TWEQ_FREE].q_min);
1811     twe_printf(sc, "ready     %04d     %04d   %04d\n", sc->twe_qstat[TWEQ_READY].q_length, sc->twe_qstat[TWEQ_READY].q_max, sc->twe_qstat[TWEQ_READY].q_min);
1812     twe_printf(sc, "busy      %04d     %04d   %04d\n", sc->twe_qstat[TWEQ_BUSY].q_length, sc->twe_qstat[TWEQ_BUSY].q_max, sc->twe_qstat[TWEQ_BUSY].q_min);
1813     twe_printf(sc, "complete  %04d     %04d   %04d\n", sc->twe_qstat[TWEQ_COMPLETE].q_length, sc->twe_qstat[TWEQ_COMPLETE].q_max, sc->twe_qstat[TWEQ_COMPLETE].q_min);
1814     twe_printf(sc, "bioq      %04d     %04d   %04d\n", sc->twe_qstat[TWEQ_BIO].q_length, sc->twe_qstat[TWEQ_BIO].q_max, sc->twe_qstat[TWEQ_BIO].q_min);
1815     twe_printf(sc, "AEN queue head %d  tail %d\n", sc->twe_aen_head, sc->twe_aen_tail);
1816 }
1817
1818 static void
1819 twe_panic(struct twe_softc *sc, char *reason)
1820 {
1821     twe_print_controller(sc);
1822 #ifdef TWE_DEBUG
1823     panic(reason);
1824 #else
1825     twe_reset(sc);
1826 #endif
1827 }
1828
1829 #if 0
1830 /********************************************************************************
1831  * Print a request/command in human-readable format.
1832  */
1833 static void
1834 twe_print_request(struct twe_request *tr)
1835 {
1836     struct twe_softc    *sc = tr->tr_sc;
1837     TWE_Command *cmd = &tr->tr_command;
1838     int         i;
1839
1840     twe_printf(sc, "CMD: request_id %d  opcode <%s>  size %d  unit %d  host_id %d\n",
1841                cmd->generic.request_id, twe_describe_code(twe_table_opcode, cmd->generic.opcode), cmd->generic.size,
1842                cmd->generic.unit, cmd->generic.host_id);
1843     twe_printf(sc, " status %d  flags 0x%x  count %d  sgl_offset %d\n",
1844                cmd->generic.status, cmd->generic.flags, cmd->generic.count, cmd->generic.sgl_offset);
1845
1846     switch(cmd->generic.opcode) {       /* XXX add more opcodes? */
1847     case TWE_OP_READ:
1848     case TWE_OP_WRITE:
1849         twe_printf(sc, " lba %d\n", cmd->io.lba);
1850         for (i = 0; (i < TWE_MAX_SGL_LENGTH) && (cmd->io.sgl[i].length != 0); i++)
1851             twe_printf(sc, "  %d: 0x%x/%d\n",
1852                        i, cmd->io.sgl[i].address, cmd->io.sgl[i].length);
1853         break;
1854
1855     case TWE_OP_GET_PARAM:
1856     case TWE_OP_SET_PARAM:
1857         for (i = 0; (i < TWE_MAX_SGL_LENGTH) && (cmd->param.sgl[i].length != 0); i++)
1858             twe_printf(sc, "  %d: 0x%x/%d\n",
1859                        i, cmd->param.sgl[i].address, cmd->param.sgl[i].length);
1860         break;
1861
1862     case TWE_OP_INIT_CONNECTION:
1863         twe_printf(sc, " response queue pointer 0x%x\n",
1864                    cmd->initconnection.response_queue_pointer);
1865         break;
1866
1867     default:
1868         break;
1869     }
1870     twe_printf(sc, " tr_command %p/0x%x  tr_data %p/0x%x,%d\n",
1871                tr, tr->tr_cmdphys, tr->tr_data, tr->tr_dataphys, tr->tr_length);
1872     twe_printf(sc, " tr_status %d  tr_flags 0x%x  tr_complete %p  tr_private %p\n",
1873                tr->tr_status, tr->tr_flags, tr->tr_complete, tr->tr_private);
1874 }
1875
1876 #endif