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.17 2006/12/20 18:14:40 dillon 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         }
 428
 429         /* did we find something to do? */
 430         if (tr == NULL)
 431             break;
 432
 433         /* try to map and submit the command to controller */
 434         error = twe_map_request(tr);
 435
 436         if (error != 0) {
 437             if (error == EBUSY)
 438                 break;
 439             tr->tr_status = TWE_CMD_ERROR;
 440             if (tr->tr_private != NULL) {
 441                 bio = (twe_bio *)tr->tr_private;
 442                 bio->bio_buf->b_error = error;
 443                 bio->bio_buf->b_flags |= B_ERROR;
 444                 tr->tr_private = NULL;
 445                 twed_intr(bio);
 446                 twe_release_request(tr);
 447             } else if (tr->tr_flags & TWE_CMD_SLEEPER)
 448                 wakeup_one(tr); /* wakeup the sleeping owner */
 449         }
 450     }
 451 }
 452
 453 /********************************************************************************
 454  * Write blocks from memory to disk, for system crash dumps.
 455  */
 456 int
 457 twe_dump_blocks(struct twe_softc *sc, int unit, u_int32_t lba, void *data, int nblks)
 458 {
 459     struct twe_request  *tr;
 460     TWE_Command         *cmd;
 461     int                 error;
 462
 463     if (twe_get_request(sc, &tr))
 464         return(ENOMEM);
 465
 466     tr->tr_data = data;
 467     tr->tr_status = TWE_CMD_SETUP;
 468     tr->tr_length = nblks * TWE_BLOCK_SIZE;
 469     tr->tr_flags = TWE_CMD_DATAOUT;
 470
 471     cmd = &tr->tr_command;
 472     cmd->io.opcode = TWE_OP_WRITE;
 473     cmd->io.size = 3;
 474     cmd->io.unit = unit;
 475     cmd->io.block_count = nblks;
 476     cmd->io.lba = lba;
 477
 478     error = twe_immediate_request(tr);
 479     if (error == 0)
 480         if (twe_report_request(tr))
 481             error = EIO;
 482     twe_release_request(tr);
 483     return(error);
 484 }
 485
 486 /********************************************************************************
 487  * Handle controller-specific control operations.
 488  */
 489 int
 490 twe_ioctl(struct twe_softc *sc, int cmd, void *addr)
 491 {
 492     struct twe_usercommand      *tu = (struct twe_usercommand *)addr;
 493     struct twe_paramcommand     *tp = (struct twe_paramcommand *)addr;
 494     struct twe_drivecommand     *td = (struct twe_drivecommand *)addr;
 495     union twe_statrequest       *ts = (union twe_statrequest *)addr;
 496     TWE_Param                   *param;
 497     void                        *data;
 498     unsigned short              *aen_code = (unsigned short *) addr;
 499     struct twe_request          *tr;
 500     u_int8_t                    srid;
 501     int                         error;
 502
 503     error = 0;
 504     switch(cmd) {
 505         /* handle a command from userspace */
 506     case TWEIO_COMMAND:
 507         /* get a request */
 508         while (twe_get_request(sc, &tr))
 509             tsleep(sc, 0, "twioctl", hz);
 510
 511         /*
 512          * Save the command's request ID, copy the user-supplied command in,
 513          * restore the request ID.
 514          */
 515         srid = tr->tr_command.generic.request_id;
 516         bcopy(&tu->tu_command, &tr->tr_command, sizeof(TWE_Command));
 517         tr->tr_command.generic.request_id = srid;
 518
 519         /*
 520          * if there's a data buffer, allocate and copy it in.
 521          * Must be in multipled of 512 bytes.
 522          */
 523         tr->tr_length = (tu->tu_size + 511) & ~511;
 524         if (tr->tr_length > 0) {
 525             if ((tr->tr_data = kmalloc(tr->tr_length, M_DEVBUF, M_WAITOK)) == NULL) {
 526                 error = ENOMEM;
 527                 goto cmd_done;
 528             }
 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         if ((data = kmalloc(tp->tp_size, M_DEVBUF, M_WAITOK)) == NULL) {
 608             error = ENOMEM;
 609         } else {
 610             error = copyin(tp->tp_data, data, tp->tp_size);
 611             if (error == 0)
 612                 error = twe_set_param(sc, tp->tp_table_id, tp->tp_param_id, tp->tp_size, data);
 613             kfree(data, M_DEVBUF);
 614         }
 615         break;
 616
 617     case TWEIO_RESET:
 618         twe_reset(sc);
 619         break;
 620
 621     case TWEIO_ADD_UNIT:
 622         error = twe_add_unit(sc, td->td_unit);
 623         break;
 624
 625     case TWEIO_DEL_UNIT:
 626         error = twe_del_unit(sc, td->td_unit);
 627         break;
 628
 629         /* XXX implement ATA PASSTHROUGH */
 630
 631         /* nothing we understand */
 632     default:
 633         error = ENOTTY;
 634     }
 635
 636     return(error);
 637 }
 638
 639 /********************************************************************************
 640  * Enable the useful interrupts from the controller.
 641  */
 642 void
 643 twe_enable_interrupts(struct twe_softc *sc)
 644 {
 645     sc->twe_state |= TWE_STATE_INTEN;
 646     TWE_CONTROL(sc,
 647                TWE_CONTROL_CLEAR_ATTENTION_INTERRUPT |
 648                TWE_CONTROL_UNMASK_RESPONSE_INTERRUPT |
 649                TWE_CONTROL_ENABLE_INTERRUPTS);
 650 }
 651
 652 /********************************************************************************
 653  * Disable interrupts from the controller.
 654  */
 655 void
 656 twe_disable_interrupts(struct twe_softc *sc)
 657 {
 658     TWE_CONTROL(sc, TWE_CONTROL_DISABLE_INTERRUPTS);
 659     sc->twe_state &= ~TWE_STATE_INTEN;
 660 }
 661
 662 /********************************************************************************
 663  ********************************************************************************
 664                                                                Command Submission
 665  ********************************************************************************
 666  ********************************************************************************/
 667
 668 /********************************************************************************
 669  * Read integer parameter table entries.
 670  */
 671 static int
 672 twe_get_param_1(struct twe_softc *sc, int table_id, int param_id, u_int8_t *result)
 673 {
 674     TWE_Param   *param;
 675
 676     if ((param = twe_get_param(sc, table_id, param_id, 1, NULL)) == NULL)
 677         return(ENOENT);
 678     *result = *(u_int8_t *)param->data;
 679     kfree(param, M_DEVBUF);
 680     return(0);
 681 }
 682
 683 static int
 684 twe_get_param_2(struct twe_softc *sc, int table_id, int param_id, u_int16_t *result)
 685 {
 686     TWE_Param   *param;
 687
 688     if ((param = twe_get_param(sc, table_id, param_id, 2, NULL)) == NULL)
 689         return(ENOENT);
 690     *result = *(u_int16_t *)param->data;
 691     kfree(param, M_DEVBUF);
 692     return(0);
 693 }
 694
 695 static int
 696 twe_get_param_4(struct twe_softc *sc, int table_id, int param_id, u_int32_t *result)
 697 {
 698     TWE_Param   *param;
 699
 700     if ((param = twe_get_param(sc, table_id, param_id, 4, NULL)) == NULL)
 701         return(ENOENT);
 702     *result = *(u_int32_t *)param->data;
 703     kfree(param, M_DEVBUF);
 704     return(0);
 705 }
 706
 707 /********************************************************************************
 708  * Perform a TWE_OP_GET_PARAM command.  If a callback function is provided, it
 709  * will be called with the command when it's completed.  If no callback is
 710  * provided, we will wait for the command to complete and then return just the data.
 711  * The caller is responsible for freeing the data when done with it.
 712  */
 713 static void *
 714 twe_get_param(struct twe_softc *sc, int table_id, int param_id, size_t param_size,
 715               void (* func)(struct twe_request *tr))
 716 {
 717     struct twe_request  *tr;
 718     TWE_Command         *cmd;
 719     TWE_Param           *param;
 720     int                 error;
 721
 722     debug_called(4);
 723
 724     tr = NULL;
 725     param = NULL;
 726
 727     /* get a command */
 728     if (twe_get_request(sc, &tr))
 729         goto err;
 730
 731     /* get a buffer */
 732     param = (TWE_Param *)kmalloc(TWE_SECTOR_SIZE, M_DEVBUF, M_INTWAIT);
 733     tr->tr_data = param;
 734     tr->tr_length = TWE_SECTOR_SIZE;
 735     tr->tr_flags = TWE_CMD_DATAIN | TWE_CMD_DATAOUT;
 736
 737     /* build the command for the controller */
 738     cmd = &tr->tr_command;
 739     cmd->param.opcode = TWE_OP_GET_PARAM;
 740     cmd->param.size = 2;
 741     cmd->param.unit = 0;
 742     cmd->param.param_count = 1;
 743
 744     /* fill in the outbound parameter data */
 745     param->table_id = table_id;
 746     param->parameter_id = param_id;
 747     param->parameter_size_bytes = param_size;
 748
 749     /* submit the command and either wait or let the callback handle it */
 750     if (func == NULL) {
 751         /* XXX could use twe_wait_request here if interrupts were enabled? */
 752         error = twe_immediate_request(tr);
 753         if (error == 0) {
 754             if (twe_report_request(tr))
 755                 goto err;
 756         }
 757         else
 758                 goto err;
 759         twe_release_request(tr);
 760         return(param);
 761     } else {
 762         tr->tr_complete = func;
 763         error = twe_map_request(tr);
 764         if ((error == 0) || (error == EBUSY))
 765             return(func);
 766     }
 767
 768     /* something failed */
 769 err:
 770     debug(1, "failed");
 771     if (tr != NULL)
 772         twe_release_request(tr);
 773     if (param != NULL)
 774         kfree(param, M_DEVBUF);
 775     return(NULL);
 776 }
 777
 778 /********************************************************************************
 779  * Set integer parameter table entries.
 780  */
 781 #ifdef TWE_SHUTDOWN_NOTIFICATION
 782 static int
 783 twe_set_param_1(struct twe_softc *sc, int table_id, int param_id, u_int8_t value)
 784 {
 785     return(twe_set_param(sc, table_id, param_id, sizeof(value), &value));
 786 }
 787 #endif
 788
 789 #if 0
 790 static int
 791 twe_set_param_2(struct twe_softc *sc, int table_id, int param_id, u_int16_t value)
 792 {
 793     return(twe_set_param(sc, table_id, param_id, sizeof(value), &value));
 794 }
 795
 796 static int
 797 twe_set_param_4(struct twe_softc *sc, int table_id, int param_id, u_int32_t value)
 798 {
 799     return(twe_set_param(sc, table_id, param_id, sizeof(value), &value));
 800 }
 801 #endif
 802
 803 /********************************************************************************
 804  * Perform a TWE_OP_SET_PARAM command, returns nonzero on error.
 805  */
 806 static int
 807 twe_set_param(struct twe_softc *sc, int table_id, int param_id, int param_size, void *data)
 808 {
 809     struct twe_request  *tr;
 810     TWE_Command         *cmd;
 811     TWE_Param           *param;
 812     int                 error;
 813
 814     debug_called(4);
 815
 816     tr = NULL;
 817     param = NULL;
 818     error = ENOMEM;
 819
 820     /* get a command */
 821     if (twe_get_request(sc, &tr))
 822         goto out;
 823
 824     /* get a buffer */
 825     param = (TWE_Param *)kmalloc(TWE_SECTOR_SIZE, M_DEVBUF, M_INTWAIT);
 826     tr->tr_data = param;
 827     tr->tr_length = TWE_SECTOR_SIZE;
 828     tr->tr_flags = TWE_CMD_DATAIN | TWE_CMD_DATAOUT;
 829
 830     /* build the command for the controller */
 831     cmd = &tr->tr_command;
 832     cmd->param.opcode = TWE_OP_SET_PARAM;
 833     cmd->param.size = 2;
 834     cmd->param.unit = 0;
 835     cmd->param.param_count = 1;
 836
 837     /* fill in the outbound parameter data */
 838     param->table_id = table_id;
 839     param->parameter_id = param_id;
 840     param->parameter_size_bytes = param_size;
 841     bcopy(data, param->data, param_size);
 842
 843     /* XXX could use twe_wait_request here if interrupts were enabled? */
 844     error = twe_immediate_request(tr);
 845     if (error == 0) {
 846         if (twe_report_request(tr))
 847             error = EIO;
 848     }
 849
 850 out:
 851     if (tr != NULL)
 852         twe_release_request(tr);
 853     if (param != NULL)
 854         kfree(param, M_DEVBUF);
 855     return(error);
 856 }
 857
 858 /********************************************************************************
 859  * Perform a TWE_OP_INIT_CONNECTION command, returns nonzero on error.
 860  *
 861  * Typically called with interrupts disabled.
 862  */
 863 static int
 864 twe_init_connection(struct twe_softc *sc, int mode)
 865 {
 866     struct twe_request  *tr;
 867     TWE_Command         *cmd;
 868     int                 error;
 869
 870     debug_called(4);
 871
 872     /* get a command */
 873     if (twe_get_request(sc, &tr))
 874         return(NULL);
 875
 876     /* build the command */
 877     cmd = &tr->tr_command;
 878     cmd->initconnection.opcode = TWE_OP_INIT_CONNECTION;
 879     cmd->initconnection.size = 3;
 880     cmd->initconnection.host_id = 0;
 881     cmd->initconnection.message_credits = mode;
 882     cmd->initconnection.response_queue_pointer = 0;
 883
 884     /* submit the command */
 885     error = twe_immediate_request(tr);
 886     twe_release_request(tr);
 887
 888     if (mode == TWE_INIT_MESSAGE_CREDITS)
 889         sc->twe_host_id = cmd->initconnection.host_id;
 890     return(error);
 891 }
 892
 893 /********************************************************************************
 894  * Start the command (tr) and sleep waiting for it to complete.
 895  *
 896  * Successfully completed commands are dequeued.
 897  */
 898 static int
 899 twe_wait_request(struct twe_request *tr)
 900 {
 901     debug_called(4);
 902
 903     tr->tr_flags |= TWE_CMD_SLEEPER;
 904     tr->tr_status = TWE_CMD_BUSY;
 905     twe_enqueue_ready(tr);
 906     twe_startio(tr->tr_sc);
 907     crit_enter();
 908     while (tr->tr_status == TWE_CMD_BUSY)
 909         tsleep(tr, 0, "twewait", 0);
 910     crit_exit();
 911
 912     return(tr->tr_status != TWE_CMD_COMPLETE);
 913 }
 914
 915 /********************************************************************************
 916  * Start the command (tr) and busy-wait for it to complete.
 917  * This should only be used when interrupts are actually disabled (although it
 918  * will work if they are not).
 919  */
 920 static int
 921 twe_immediate_request(struct twe_request *tr)
 922 {
 923     int         error;
 924
 925     debug_called(4);
 926
 927     tr->tr_status = TWE_CMD_BUSY;
 928     if ((error = twe_map_request(tr)) != 0)
 929         if (error != EBUSY)
 930             return(error);
 931     while (tr->tr_status == TWE_CMD_BUSY){
 932         twe_done(tr->tr_sc);
 933     }
 934     return(tr->tr_status != TWE_CMD_COMPLETE);
 935 }
 936
 937 /********************************************************************************
 938  * Handle completion of an I/O command.
 939  */
 940 static void
 941 twe_completeio(struct twe_request *tr)
 942 {
 943     struct twe_softc    *sc = tr->tr_sc;
 944     struct bio          *bio = (twe_bio *)tr->tr_private;
 945     struct buf          *bp = bio->bio_buf;
 946
 947     debug_called(4);
 948
 949     if (tr->tr_status == TWE_CMD_COMPLETE) {
 950         if (tr->tr_command.generic.status)
 951                 if (twe_report_request(tr)) {
 952                         bp->b_error = EIO;
 953                         bp->b_flags |= B_ERROR;
 954                 }
 955     } else {
 956         twe_panic(sc, "twe_completeio on incomplete command");
 957     }
 958     tr->tr_private = NULL;
 959     twed_intr(bio);
 960     twe_release_request(tr);
 961 }
 962
 963 /********************************************************************************
 964  * Reset the controller and pull all the active commands back onto the ready
 965  * queue.  Used to restart a controller that's exhibiting bad behaviour.
 966  */
 967 static void
 968 twe_reset(struct twe_softc *sc)
 969 {
 970     struct twe_request  *tr;
 971     int                 i;
 972
 973     /*
 974      * Sleep for a short period to allow AENs to be signalled.
 975      */
 976     tsleep(sc, 0, "twereset", hz);
 977
 978     /*
 979      * Disable interrupts from the controller, and mask any accidental entry
 980      * into our interrupt handler.
 981      */
 982     twe_printf(sc, "controller reset in progress...\n");
 983     twe_disable_interrupts(sc);
 984     crit_enter();
 985
 986     /*
 987      * Try to soft-reset the controller.
 988      */
 989     for (i = 0; i < TWE_MAX_RESET_TRIES; i++) {
 990
 991         if (i > 0)
 992             twe_printf(sc, "reset %d failed, trying again\n", i);
 993
 994         if (!twe_soft_reset(sc))
 995             break;                      /* reset process complete */
 996     }
 997     /* did we give up? */
 998     if (i >= TWE_MAX_RESET_TRIES) {
 999         twe_printf(sc, "can't reset controller, giving up\n");
1000         goto out;
1001     }
1002
1003     /*
1004      * Move all of the commands that were busy back to the ready queue.
1005      */
1006     i = 0;
1007     while ((tr = twe_dequeue_busy(sc)) != NULL) {
1008         twe_enqueue_ready(tr);
1009         i++;
1010     }
1011
1012     /*
1013      * Kick the controller to start things going again, then re-enable interrupts.
1014      */
1015     twe_startio(sc);
1016     twe_enable_interrupts(sc);
1017     twe_printf(sc, "controller reset done, %d commands restarted\n", i);
1018
1019 out:
1020     crit_exit();
1021     twe_enable_interrupts(sc);
1022 }
1023
1024 /********************************************************************************
1025  ********************************************************************************
1026                                                         Command I/O to Controller
1027  ********************************************************************************
1028  ********************************************************************************/
1029
1030 /********************************************************************************
1031  * Try to deliver (tr) to the controller.
1032  *
1033  * Can be called at any interrupt level, with or without interrupts enabled.
1034  */
1035 int
1036 twe_start(struct twe_request *tr)
1037 {
1038     struct twe_softc    *sc = tr->tr_sc;
1039     int                 i, done;
1040     u_int32_t           status_reg;
1041
1042     debug_called(4);
1043
1044     /* mark the command as currently being processed */
1045     tr->tr_status = TWE_CMD_BUSY;
1046
1047     /*
1048      * Spin briefly waiting for the controller to come ready
1049      *
1050      * XXX it might be more efficient to return EBUSY immediately
1051      *     and let the command be rescheduled.
1052      */
1053     for (i = 100000, done = 0; (i > 0) && !done; i--) {
1054         crit_enter();
1055
1056         /* check to see if we can post a command */
1057         status_reg = TWE_STATUS(sc);
1058         twe_check_bits(sc, status_reg);
1059
1060         if (!(status_reg & TWE_STATUS_COMMAND_QUEUE_FULL)) {
1061             /* move command to work queue */
1062             twe_enqueue_busy(tr);
1063             TWE_COMMAND_QUEUE(sc, tr->tr_cmdphys);
1064             done = 1;
1065 #ifdef TWE_DEBUG
1066             if (tr->tr_complete != NULL) {
1067                 debug(3, "queued request %d with callback %p", tr->tr_command.generic.request_id, tr->tr_complete);
1068             } else if (tr->tr_flags & TWE_CMD_SLEEPER) {
1069                 debug(3, "queued request %d with wait channel %p", tr->tr_command.generic.request_id, tr);
1070             } else {
1071                 debug(3, "queued request %d for polling caller", tr->tr_command.generic.request_id);
1072             }
1073 #endif
1074         }
1075         crit_exit();    /* drop critical section to allow completion interrupts */
1076     }
1077
1078     /* command is enqueued */
1079     if (done)
1080         return(0);
1081
1082     /*
1083      * We couldn't get the controller to take the command; try submitting it again later.
1084      * This should only happen if something is wrong with the controller, or if we have
1085      * overestimated the number of commands it can accept.  (Should we actually reject
1086      * the command at this point?)
1087      */
1088     return(EBUSY);
1089 }
1090
1091 /********************************************************************************
1092  * Poll the controller (sc) for completed commands.
1093  *
1094  * Can be called at any interrupt level, with or without interrupts enabled.
1095  */
1096 static void
1097 twe_done(struct twe_softc *sc)
1098 {
1099     TWE_Response_Queue  rq;
1100     struct twe_request  *tr;
1101     int                 found;
1102     u_int32_t           status_reg;
1103
1104     debug_called(5);
1105
1106     /* loop collecting completed commands */
1107     found = 0;
1108     crit_enter();
1109     for (;;) {
1110         status_reg = TWE_STATUS(sc);
1111         twe_check_bits(sc, status_reg);         /* XXX should this fail? */
1112
1113         if (!(status_reg & TWE_STATUS_RESPONSE_QUEUE_EMPTY)) {
1114             found = 1;
1115             rq = TWE_RESPONSE_QUEUE(sc);
1116             tr = sc->twe_lookup[rq.u.response_id];      /* find command */
1117             if (tr->tr_status != TWE_CMD_BUSY)
1118                 twe_printf(sc, "completion event for nonbusy command\n");
1119             tr->tr_status = TWE_CMD_COMPLETE;
1120             debug(3, "completed request id %d with status %d",
1121                   tr->tr_command.generic.request_id, tr->tr_command.generic.status);
1122             /* move to completed queue */
1123             twe_remove_busy(tr);
1124             twe_enqueue_complete(tr);
1125             sc->twe_state &= ~TWE_STATE_CTLR_BUSY;
1126         } else {
1127             break;                                      /* no response ready */
1128         }
1129     }
1130     crit_exit();
1131
1132     /* if we've completed any commands, try posting some more */
1133     if (found)
1134         twe_startio(sc);
1135
1136     /* handle completion and timeouts */
1137     twe_complete(sc);           /* XXX use deferred completion? */
1138 }
1139
1140 /********************************************************************************
1141  * Perform post-completion processing for commands on (sc).
1142  *
1143  * This is split from twe_done as it can be safely deferred and run at a lower
1144  * priority level should facilities for such a thing become available.
1145  */
1146 static void
1147 twe_complete(struct twe_softc *sc)
1148 {
1149     struct twe_request  *tr;
1150
1151     debug_called(5);
1152
1153     /*
1154      * Pull commands off the completed list, dispatch them appropriately
1155      */
1156     while ((tr = twe_dequeue_complete(sc)) != NULL) {
1157
1158         /* unmap the command's data buffer */
1159         twe_unmap_request(tr);
1160
1161         /* dispatch to suit command originator */
1162         if (tr->tr_complete != NULL) {          /* completion callback */
1163             debug(2, "call completion handler %p", tr->tr_complete);
1164             tr->tr_complete(tr);
1165
1166         } else if (tr->tr_flags & TWE_CMD_SLEEPER) {    /* caller is asleep waiting */
1167             debug(2, "wake up command owner on %p", tr);
1168             wakeup_one(tr);
1169
1170         } else {                                        /* caller is polling command */
1171             debug(2, "command left for owner");
1172         }
1173     }
1174 }
1175
1176 /********************************************************************************
1177  * Wait for (status) to be set in the controller status register for up to
1178  * (timeout) seconds.  Returns 0 if found, nonzero if we time out.
1179  *
1180  * Note: this busy-waits, rather than sleeping, since we may be called with
1181  * eg. clock interrupts masked.
1182  */
1183 static int
1184 twe_wait_status(struct twe_softc *sc, u_int32_t status, int timeout)
1185 {
1186     time_t      expiry;
1187     u_int32_t   status_reg;
1188
1189     debug_called(4);
1190
1191     expiry = time_second + timeout;
1192
1193     do {
1194         status_reg = TWE_STATUS(sc);
1195         if (status_reg & status)        /* got the required bit(s)? */
1196             return(0);
1197         DELAY(100000);
1198     } while (time_second <= expiry);
1199
1200     return(1);
1201 }
1202
1203 /********************************************************************************
1204  * Drain the response queue, which may contain responses to commands we know
1205  * nothing about.
1206  */
1207 static int
1208 twe_drain_response_queue(struct twe_softc *sc)
1209 {
1210     TWE_Response_Queue  rq;
1211     u_int32_t           status_reg;
1212
1213     debug_called(4);
1214
1215     for (;;) {                          /* XXX give up eventually? */
1216         status_reg = TWE_STATUS(sc);
1217         if (twe_check_bits(sc, status_reg))
1218             return(1);
1219         if (status_reg & TWE_STATUS_RESPONSE_QUEUE_EMPTY)
1220             return(0);
1221         rq = TWE_RESPONSE_QUEUE(sc);
1222     }
1223 }
1224
1225 /********************************************************************************
1226  * Soft-reset the controller
1227  */
1228 static int
1229 twe_soft_reset(struct twe_softc *sc)
1230 {
1231     u_int32_t           status_reg;
1232
1233     debug_called(2);
1234
1235     TWE_SOFT_RESET(sc);
1236
1237     if (twe_wait_status(sc, TWE_STATUS_ATTENTION_INTERRUPT, 30)) {
1238         twe_printf(sc, "no attention interrupt\n");
1239         return(1);
1240     }
1241     TWE_CONTROL(sc, TWE_CONTROL_CLEAR_ATTENTION_INTERRUPT);
1242     if (twe_drain_aen_queue(sc)) {
1243         twe_printf(sc, "can't drain AEN queue\n");
1244         return(1);
1245     }
1246     if (twe_find_aen(sc, TWE_AEN_SOFT_RESET)) {
1247         twe_printf(sc, "reset not reported\n");
1248         return(1);
1249     }
1250     status_reg = TWE_STATUS(sc);
1251     if (TWE_STATUS_ERRORS(status_reg) || twe_check_bits(sc, status_reg)) {
1252         twe_printf(sc, "controller errors detected\n");
1253         return(1);
1254     }
1255     if (twe_drain_response_queue(sc)) {
1256         twe_printf(sc, "can't drain response queue\n");
1257         return(1);
1258     }
1259     return(0);
1260 }
1261
1262 /********************************************************************************
1263  ********************************************************************************
1264                                                                Interrupt Handling
1265  ********************************************************************************
1266  ********************************************************************************/
1267
1268 /********************************************************************************
1269  * Host interrupt.
1270  *
1271  * XXX what does this mean?
1272  */
1273 static void
1274 twe_host_intr(struct twe_softc *sc)
1275 {
1276     debug_called(4);
1277
1278     twe_printf(sc, "host interrupt\n");
1279     TWE_CONTROL(sc, TWE_CONTROL_CLEAR_HOST_INTERRUPT);
1280 }
1281
1282 /********************************************************************************
1283  * Attention interrupt.
1284  *
1285  * Signalled when the controller has one or more AENs for us.
1286  */
1287 static void
1288 twe_attention_intr(struct twe_softc *sc)
1289 {
1290     debug_called(4);
1291
1292     /* instigate a poll for AENs */
1293     if (twe_fetch_aen(sc)) {
1294         twe_printf(sc, "error polling for signalled AEN\n");
1295     } else {
1296         TWE_CONTROL(sc, TWE_CONTROL_CLEAR_ATTENTION_INTERRUPT);
1297     }
1298 }
1299
1300 /********************************************************************************
1301  * Command interrupt.
1302  *
1303  * Signalled when the controller can handle more commands.
1304  */
1305 static void
1306 twe_command_intr(struct twe_softc *sc)
1307 {
1308     debug_called(4);
1309
1310     /*
1311      * We don't use this, rather we try to submit commands when we receive
1312      * them, and when other commands have completed.  Mask it so we don't get
1313      * another one.
1314     twe_printf(sc, "command interrupt\n");
1315      */
1316     TWE_CONTROL(sc, TWE_CONTROL_MASK_COMMAND_INTERRUPT);
1317 }
1318
1319 /********************************************************************************
1320  ********************************************************************************
1321                                                       Asynchronous Event Handling
1322  ********************************************************************************
1323  ********************************************************************************/
1324
1325 /********************************************************************************
1326  * Request an AEN from the controller.
1327  */
1328 static int
1329 twe_fetch_aen(struct twe_softc *sc)
1330 {
1331
1332     debug_called(4);
1333
1334     if ((twe_get_param(sc, TWE_PARAM_AEN, TWE_PARAM_AEN_UnitCode, 2, twe_handle_aen)) == NULL)
1335         return(EIO);
1336     return(0);
1337 }
1338
1339 /********************************************************************************
1340  * Handle an AEN returned by the controller.
1341  */
1342 static void
1343 twe_handle_aen(struct twe_request *tr)
1344 {
1345     struct twe_softc    *sc = tr->tr_sc;
1346     TWE_Param           *param;
1347     u_int16_t           aen;
1348
1349     debug_called(4);
1350
1351     /* XXX check for command success somehow? */
1352
1353     param = (TWE_Param *)tr->tr_data;
1354     aen = *(u_int16_t *)(param->data);
1355
1356     kfree(tr->tr_data, M_DEVBUF);
1357     twe_release_request(tr);
1358     twe_enqueue_aen(sc, aen);
1359
1360     /* XXX poll for more AENs? */
1361 }
1362
1363 /********************************************************************************
1364  * Pull AENs out of the controller and park them in the queue, in a context where
1365  * interrupts aren't active.  Return nonzero if we encounter any errors in the
1366  * process of obtaining all the available AENs.
1367  */
1368 static int
1369 twe_drain_aen_queue(struct twe_softc *sc)
1370 {
1371     u_int16_t   aen;
1372
1373     for (;;) {
1374         if (twe_get_param_2(sc, TWE_PARAM_AEN, TWE_PARAM_AEN_UnitCode, &aen))
1375             return(1);
1376         if (aen == TWE_AEN_QUEUE_EMPTY)
1377             return(0);
1378         twe_enqueue_aen(sc, aen);
1379     }
1380 }
1381
1382 /********************************************************************************
1383  * Push an AEN that we've received onto the queue.
1384  *
1385  * Note that we have to lock this against reentrance, since it may be called
1386  * from both interrupt and non-interrupt context.
1387  *
1388  * If someone is waiting for the AEN we have, wake them up.
1389  */
1390 static void
1391 twe_enqueue_aen(struct twe_softc *sc, u_int16_t aen)
1392 {
1393     char        *msg;
1394     int         next, nextnext;
1395
1396     debug_called(4);
1397
1398     if ((msg = twe_format_aen(sc, aen)) != NULL)
1399         twe_printf(sc, "AEN: <%s>\n", msg);
1400
1401     crit_enter();
1402     /* enqueue the AEN */
1403     next = ((sc->twe_aen_head + 1) % TWE_Q_LENGTH);
1404     nextnext = ((sc->twe_aen_head + 2) % TWE_Q_LENGTH);
1405
1406     /* check to see if this is the last free slot, and subvert the AEN if it is */
1407     if (nextnext == sc->twe_aen_tail)
1408         aen = TWE_AEN_QUEUE_FULL;
1409
1410     /* look to see if there's room for this AEN */
1411     if (next != sc->twe_aen_tail) {
1412         sc->twe_aen_queue[sc->twe_aen_head] = aen;
1413         sc->twe_aen_head = next;
1414     }
1415
1416     /* wake up anyone asleep on the queue */
1417     wakeup(&sc->twe_aen_queue);
1418
1419     /* anyone looking for this AEN? */
1420     if (sc->twe_wait_aen == aen) {
1421         sc->twe_wait_aen = -1;
1422         wakeup(&sc->twe_wait_aen);
1423     }
1424     crit_exit();
1425 }
1426
1427 /********************************************************************************
1428  * Pop an AEN off the queue, or return -1 if there are none left.
1429  *
1430  * We are more or less interrupt-safe, so don't block interrupts.
1431  */
1432 static u_int16_t
1433 twe_dequeue_aen(struct twe_softc *sc)
1434 {
1435     u_int16_t   result;
1436
1437     debug_called(4);
1438
1439     if (sc->twe_aen_tail == sc->twe_aen_head) {
1440         result = TWE_AEN_QUEUE_EMPTY;
1441     } else {
1442         result = sc->twe_aen_queue[sc->twe_aen_tail];
1443         sc->twe_aen_tail = ((sc->twe_aen_tail + 1) % TWE_Q_LENGTH);
1444     }
1445     return(result);
1446 }
1447
1448 /********************************************************************************
1449  * Check to see if the requested AEN is in the queue.
1450  *
1451  * XXX we could probably avoid masking interrupts here
1452  */
1453 static int
1454 twe_find_aen(struct twe_softc *sc, u_int16_t aen)
1455 {
1456     int         i, missing;
1457
1458     missing = 1;
1459     crit_enter();
1460     for (i = sc->twe_aen_tail; (i != sc->twe_aen_head) && missing; i = (i + 1) % TWE_Q_LENGTH) {
1461         if (sc->twe_aen_queue[i] == aen)
1462             missing = 0;
1463     }
1464     crit_exit();
1465     return(missing);
1466 }
1467
1468
1469 #if 0   /* currently unused */
1470 /********************************************************************************
1471  * Sleep waiting for at least (timeout) seconds until we see (aen) as
1472  * requested.  Returns nonzero on timeout or failure.
1473  *
1474  * XXX: this should not be used in cases where there may be more than one sleeper
1475  *      without a mechanism for registering multiple sleepers.
1476  */
1477 static int
1478 twe_wait_aen(struct twe_softc *sc, int aen, int timeout)
1479 {
1480     time_t      expiry;
1481     int         found;
1482
1483     debug_called(4);
1484
1485     expiry = time_second + timeout;
1486     found = 0;
1487
1488     crit_enter();
1489     sc->twe_wait_aen = aen;
1490     do {
1491         twe_fetch_aen(sc);
1492         tsleep(&sc->twe_wait_aen, PZERO, "twewaen", hz);
1493         if (sc->twe_wait_aen == -1)
1494             found = 1;
1495     } while ((time_second <= expiry) && !found);
1496     crit_exit();
1497     return(!found);
1498 }
1499 #endif
1500
1501 /********************************************************************************
1502  ********************************************************************************
1503                                                         Command Buffer Management
1504  ********************************************************************************
1505  ********************************************************************************/
1506
1507 /********************************************************************************
1508  * Get a new command buffer.
1509  *
1510  * This will return NULL if all command buffers are in use.
1511  */
1512 static int
1513 twe_get_request(struct twe_softc *sc, struct twe_request **tr)
1514 {
1515     debug_called(4);
1516
1517     /* try to reuse an old buffer */
1518     *tr = twe_dequeue_free(sc);
1519
1520     /* initialise some fields to their defaults */
1521     if (*tr != NULL) {
1522         (*tr)->tr_data = NULL;
1523         (*tr)->tr_private = NULL;
1524         (*tr)->tr_status = TWE_CMD_SETUP;               /* command is in setup phase */
1525         (*tr)->tr_flags = 0;
1526         (*tr)->tr_complete = NULL;
1527         (*tr)->tr_command.generic.status = 0;           /* before submission to controller */
1528         (*tr)->tr_command.generic.flags = 0;            /* not used */
1529     }
1530     return(*tr == NULL);
1531 }
1532
1533 /********************************************************************************
1534  * Release a command buffer for reuse.
1535  *
1536  */
1537 static void
1538 twe_release_request(struct twe_request *tr)
1539 {
1540     debug_called(4);
1541
1542     if (tr->tr_private != NULL)
1543         twe_panic(tr->tr_sc, "tr_private != NULL");
1544     twe_enqueue_free(tr);
1545 }
1546
1547 /********************************************************************************
1548  ********************************************************************************
1549                                                                         Debugging
1550  ********************************************************************************
1551  ********************************************************************************/
1552
1553 /********************************************************************************
1554  * Print some information about the controller
1555  */
1556 void
1557 twe_describe_controller(struct twe_softc *sc)
1558 {
1559     TWE_Param           *p[6];
1560     u_int8_t            ports;
1561     u_int32_t           size;
1562     int                 i;
1563
1564     debug_called(2);
1565
1566     /* get the port count */
1567     twe_get_param_1(sc, TWE_PARAM_CONTROLLER, TWE_PARAM_CONTROLLER_PortCount, &ports);
1568
1569     /* get version strings */
1570     p[0] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_FW,   16, NULL);
1571     p[1] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_BIOS, 16, NULL);
1572
1573     if (p[0] && p[1])
1574             twe_printf(sc, "%d ports, Firmware %.16s, BIOS %.16s\n", ports, p[0]->data, p[1]->data);
1575     if (bootverbose) {
1576         p[2] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_Mon,  16, NULL);
1577         p[3] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_PCB,  8, NULL);
1578         p[4] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_ATA,  8, NULL);
1579         p[5] = twe_get_param(sc, TWE_PARAM_VERSION, TWE_PARAM_VERSION_PCI,  8, NULL);
1580
1581         if (p[2] && p[3] && p[4] && p[5])
1582                 twe_printf(sc, "Monitor %.16s, PCB %.8s, Achip %.8s, Pchip %.8s\n",
1583                         p[2]->data, p[3]->data, p[4]->data, p[5]->data);
1584
1585         if (p[2])
1586                 kfree(p[2], M_DEVBUF);
1587         if (p[3])
1588                 kfree(p[3], M_DEVBUF);
1589         if (p[4])
1590                 kfree(p[4], M_DEVBUF);
1591         if (p[5])
1592                 kfree(p[5], M_DEVBUF);
1593     }
1594     if (p[0])
1595         kfree(p[0], M_DEVBUF);
1596     if (p[1])
1597         kfree(p[1], M_DEVBUF);
1598
1599     /* print attached drives */
1600     if (bootverbose) {
1601         p[0] = twe_get_param(sc, TWE_PARAM_DRIVESUMMARY, TWE_PARAM_DRIVESUMMARY_Status, 16, NULL);
1602         for (i = 0; i < ports; i++) {
1603             if (p[0]->data[i] != TWE_PARAM_DRIVESTATUS_Present)
1604                 continue;
1605             twe_get_param_4(sc, TWE_PARAM_DRIVEINFO + i, TWE_PARAM_DRIVEINFO_Size, &size);
1606             p[1] = twe_get_param(sc, TWE_PARAM_DRIVEINFO + i, TWE_PARAM_DRIVEINFO_Model, 40, NULL);
1607             if (p[1] != NULL) {
1608                 twe_printf(sc, "port %d: %.40s %dMB\n", i, p[1]->data, size / 2048);
1609                 kfree(p[1], M_DEVBUF);
1610             } else {
1611                 twe_printf(sc, "port %d, drive status unavailable\n", i);
1612             }
1613         }
1614         if (p[0])
1615             kfree(p[0], M_DEVBUF);
1616     }
1617 }
1618
1619
1620 /********************************************************************************
1621  * Look up a text description of a numeric code and return a pointer to same.
1622  */
1623 char *
1624 twe_describe_code(struct twe_code_lookup *table, u_int32_t code)
1625 {
1626     int         i;
1627
1628     for (i = 0; table[i].string != NULL; i++)
1629         if (table[i].code == code)
1630             return(table[i].string);
1631     return(table[i+1].string);
1632 }
1633
1634
1635 /********************************************************************************
1636  * Complain if the status bits aren't what we're expecting.
1637  *
1638  * Rate-limit the complaints to at most one of each every five seconds, but
1639  * always return the correct status.
1640  */
1641 static int
1642 twe_check_bits(struct twe_softc *sc, u_int32_t status_reg)
1643 {
1644     int                 result;
1645     static time_t       lastwarn[2] = {0, 0};
1646
1647     /*
1648      * This can be a little problematic, as twe_panic may call twe_reset if
1649      * TWE_DEBUG is not set, which will call us again as part of the soft reset.
1650      */
1651     if ((status_reg & TWE_STATUS_PANIC_BITS) != 0) {
1652         twe_printf(sc, "FATAL STATUS BIT(S) %b\n", status_reg & TWE_STATUS_PANIC_BITS,
1653                    TWE_STATUS_BITS_DESCRIPTION);
1654         twe_panic(sc, "fatal status bits");
1655     }
1656
1657     result = 0;
1658     if ((status_reg & TWE_STATUS_EXPECTED_BITS) != TWE_STATUS_EXPECTED_BITS) {
1659         if (time_second > (lastwarn[0] + 5)) {
1660             twe_printf(sc, "missing expected status bit(s) %b\n", ~status_reg & TWE_STATUS_EXPECTED_BITS,
1661                        TWE_STATUS_BITS_DESCRIPTION);
1662             lastwarn[0] = time_second;
1663         }
1664         result = 1;
1665     }
1666
1667     if ((status_reg & TWE_STATUS_UNEXPECTED_BITS) != 0) {
1668         if (time_second > (lastwarn[1] + 5)) {
1669             twe_printf(sc, "unexpected status bit(s) %b\n", status_reg & TWE_STATUS_UNEXPECTED_BITS,
1670                        TWE_STATUS_BITS_DESCRIPTION);
1671             lastwarn[1] = time_second;
1672         }
1673         result = 1;
1674         if (status_reg & TWE_STATUS_PCI_PARITY_ERROR) {
1675             twe_printf(sc, "PCI parity error: Reseat card, move card or buggy device present.");
1676             twe_clear_pci_parity_error(sc);
1677         }
1678         if (status_reg & TWE_STATUS_PCI_ABORT) {
1679             twe_printf(sc, "PCI abort, clearing.");
1680             twe_clear_pci_abort(sc);
1681         }
1682     }
1683
1684     return(result);
1685 }
1686
1687 /********************************************************************************
1688  * Return a string describing (aen).
1689  *
1690  * The low 8 bits of the aen are the code, the high 8 bits give the unit number
1691  * where an AEN is specific to a unit.
1692  *
1693  * Note that we could expand this routine to handle eg. up/downgrading the status
1694  * of a drive if we had some idea of what the drive's initial status was.
1695  */
1696
1697 static char *
1698 twe_format_aen(struct twe_softc *sc, u_int16_t aen)
1699 {
1700     static char buf[80];
1701     device_t    child;
1702     char        *code, *msg;
1703
1704     code = twe_describe_code(twe_table_aen, TWE_AEN_CODE(aen));
1705     msg = code + 2;
1706
1707     switch (*code) {
1708     case 'q':
1709         if (!bootverbose)
1710             return(NULL);
1711         /* FALLTHROUGH */
1712     case 'a':
1713         return(msg);
1714
1715     case 'c':
1716         if ((child = sc->twe_drive[TWE_AEN_UNIT(aen)].td_disk) != NULL) {
1717             ksprintf(buf, "twed%d: %s", device_get_unit(child), msg);
1718         } else {
1719             ksprintf(buf, "twe%d: %s for unknown unit %d", device_get_unit(sc->twe_dev),
1720                     msg, TWE_AEN_UNIT(aen));
1721         }
1722         return(buf);
1723
1724     case 'p':
1725         ksprintf(buf, "twe%d: port %d: %s", device_get_unit(sc->twe_dev), TWE_AEN_UNIT(aen),
1726                 msg);
1727         return(buf);
1728
1729
1730     case 'x':
1731     default:
1732         break;
1733     }
1734     ksprintf(buf, "unknown AEN 0x%x", aen);
1735     return(buf);
1736 }
1737
1738 /********************************************************************************
1739  * Print a diagnostic if the status of the command warrants it, and return
1740  * either zero (command was ok) or nonzero (command failed).
1741  */
1742 static int
1743 twe_report_request(struct twe_request *tr)
1744 {
1745     struct twe_softc    *sc = tr->tr_sc;
1746     TWE_Command         *cmd = &tr->tr_command;
1747     int                 result = 0;
1748
1749     /*
1750      * Check the command status value and handle accordingly.
1751      */
1752     if (cmd->generic.status == TWE_STATUS_RESET) {
1753         /*
1754          * The status code 0xff requests a controller reset.
1755          */
1756         twe_printf(sc, "command returned with controller reset request\n");
1757         twe_reset(sc);
1758         result = 1;
1759     } else if (cmd->generic.status > TWE_STATUS_FATAL) {
1760         /*
1761          * Fatal errors that don't require controller reset.
1762          *
1763          * We know a few special flags values.
1764          */
1765         switch (cmd->generic.flags) {
1766         case 0x1b:
1767             device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1768                           "drive timeout");
1769             break;
1770         case 0x51:
1771             device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1772                           "unrecoverable drive error");
1773             break;
1774         default:
1775             device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1776                           "controller error - %s (flags = 0x%x)\n",
1777                           twe_describe_code(twe_table_status, cmd->generic.status),
1778                           cmd->generic.flags);
1779             result = 1;
1780         }
1781     } else if (cmd->generic.status > TWE_STATUS_WARNING) {
1782         /*
1783          * Warning level status.
1784          */
1785         device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1786                       "warning - %s (flags = 0x%x)\n",
1787                       twe_describe_code(twe_table_status, cmd->generic.status),
1788                       cmd->generic.flags);
1789     } else if (cmd->generic.status > 0x40) {
1790         /*
1791          * Info level status.
1792          */
1793         device_printf(sc->twe_drive[cmd->generic.unit].td_disk,
1794                       "attention - %s (flags = 0x%x)\n",
1795                       twe_describe_code(twe_table_status, cmd->generic.status),
1796                       cmd->generic.flags);
1797     }
1798
1799     return(result);
1800 }
1801
1802 /********************************************************************************
1803  * Print some controller state to aid in debugging error/panic conditions
1804  */
1805 void
1806 twe_print_controller(struct twe_softc *sc)
1807 {
1808     u_int32_t           status_reg;
1809
1810     status_reg = TWE_STATUS(sc);
1811     twe_printf(sc, "status   %b\n", status_reg, TWE_STATUS_BITS_DESCRIPTION);
1812     twe_printf(sc, "          current  max    min\n");
1813     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);
1814     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);
1815     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);
1816     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);
1817     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);
1818     twe_printf(sc, "AEN queue head %d  tail %d\n", sc->twe_aen_head, sc->twe_aen_tail);
1819 }
1820
1821 static void
1822 twe_panic(struct twe_softc *sc, char *reason)
1823 {
1824     twe_print_controller(sc);
1825 #ifdef TWE_DEBUG
1826     panic(reason);
1827 #else
1828     twe_reset(sc);
1829 #endif
1830 }
1831
1832 #if 0
1833 /********************************************************************************
1834  * Print a request/command in human-readable format.
1835  */
1836 static void
1837 twe_print_request(struct twe_request *tr)
1838 {
1839     struct twe_softc    *sc = tr->tr_sc;
1840     TWE_Command *cmd = &tr->tr_command;
1841     int         i;
1842
1843     twe_printf(sc, "CMD: request_id %d  opcode <%s>  size %d  unit %d  host_id %d\n",
1844                cmd->generic.request_id, twe_describe_code(twe_table_opcode, cmd->generic.opcode), cmd->generic.size,
1845                cmd->generic.unit, cmd->generic.host_id);
1846     twe_printf(sc, " status %d  flags 0x%x  count %d  sgl_offset %d\n",
1847                cmd->generic.status, cmd->generic.flags, cmd->generic.count, cmd->generic.sgl_offset);
1848
1849     switch(cmd->generic.opcode) {       /* XXX add more opcodes? */
1850     case TWE_OP_READ:
1851     case TWE_OP_WRITE:
1852         twe_printf(sc, " lba %d\n", cmd->io.lba);
1853         for (i = 0; (i < TWE_MAX_SGL_LENGTH) && (cmd->io.sgl[i].length != 0); i++)
1854             twe_printf(sc, "  %d: 0x%x/%d\n",
1855                        i, cmd->io.sgl[i].address, cmd->io.sgl[i].length);
1856         break;
1857
1858     case TWE_OP_GET_PARAM:
1859     case TWE_OP_SET_PARAM:
1860         for (i = 0; (i < TWE_MAX_SGL_LENGTH) && (cmd->param.sgl[i].length != 0); i++)
1861             twe_printf(sc, "  %d: 0x%x/%d\n",
1862                        i, cmd->param.sgl[i].address, cmd->param.sgl[i].length);
1863         break;
1864
1865     case TWE_OP_INIT_CONNECTION:
1866         twe_printf(sc, " response queue pointer 0x%x\n",
1867                    cmd->initconnection.response_queue_pointer);
1868         break;
1869
1870     default:
1871         break;
1872     }
1873     twe_printf(sc, " tr_command %p/0x%x  tr_data %p/0x%x,%d\n",
1874                tr, tr->tr_cmdphys, tr->tr_data, tr->tr_dataphys, tr->tr_length);
1875     twe_printf(sc, " tr_status %d  tr_flags 0x%x  tr_complete %p  tr_private %p\n",
1876                tr->tr_status, tr->tr_flags, tr->tr_complete, tr->tr_private);
1877 }
1878
1879 #endif