sys/dev/disk/mpt/mpt.c

   1 /* $FreeBSD: src/sys/dev/mpt/mpt.c,v 1.3.2.3 2002/09/24 21:37:24 mjacob Exp $ */
   2 /* $DragonFly: src/sys/dev/disk/mpt/mpt.c,v 1.4 2004/09/19 00:25:57 joerg Exp $ */
   3 /*
   4  * Generic routines for LSI '909 FC  adapters.
   5  * FreeBSD Version.
   6  *
   7  * Copyright (c) 2000, 2001 by Greg Ansley
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice immediately at the beginning of the file, without modification,
  14  *    this list of conditions, and the following disclaimer.
  15  * 2. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30 /*
  31  * Additional Copyright (c) 2002 by Matthew Jacob under same license.
  32  */
  33
  34 #include "mpt_freebsd.h"
  35
  36 #define MPT_MAX_TRYS 3
  37 #define MPT_MAX_WAIT 300000
  38
  39 static int maxwait_ack = 0;
  40 static int maxwait_int = 0;
  41 static int maxwait_state = 0;
  42
  43 static __inline u_int32_t mpt_rd_db(mpt_softc_t *mpt);
  44 static __inline  u_int32_t mpt_rd_intr(mpt_softc_t *mpt);
  45
  46 static __inline u_int32_t
  47 mpt_rd_db(mpt_softc_t *mpt)
  48 {
  49         return mpt_read(mpt, MPT_OFFSET_DOORBELL);
  50 }
  51
  52 static __inline u_int32_t
  53 mpt_rd_intr(mpt_softc_t *mpt)
  54 {
  55         return mpt_read(mpt, MPT_OFFSET_INTR_STATUS);
  56 }
  57
  58 /* Busy wait for a door bell to be read by IOC */
  59 static int
  60 mpt_wait_db_ack(mpt_softc_t *mpt)
  61 {
  62         int i;
  63         for (i=0; i < MPT_MAX_WAIT; i++) {
  64                 if (!MPT_DB_IS_BUSY(mpt_rd_intr(mpt))) {
  65                         maxwait_ack = i > maxwait_ack ? i : maxwait_ack;
  66                         return MPT_OK;
  67                 }
  68
  69                 DELAY(100);
  70         }
  71         return MPT_FAIL;
  72 }
  73
  74 /* Busy wait for a door bell interrupt */
  75 static int
  76 mpt_wait_db_int(mpt_softc_t *mpt)
  77 {
  78         int i;
  79         for (i=0; i < MPT_MAX_WAIT; i++) {
  80                 if (MPT_DB_INTR(mpt_rd_intr(mpt))) {
  81                         maxwait_int = i > maxwait_int ? i : maxwait_int;
  82                         return MPT_OK;
  83                 }
  84                 DELAY(100);
  85         }
  86         return MPT_FAIL;
  87 }
  88
  89 /* Wait for IOC to transition to a give state */
  90 void
  91 mpt_check_doorbell(mpt_softc_t *mpt)
  92 {
  93         u_int32_t db = mpt_rd_db(mpt);
  94         if (MPT_STATE(db) != MPT_DB_STATE_RUNNING) {
  95                 device_printf(mpt->dev, "Device not running!\n");
  96                 mpt_print_db(db);
  97         }
  98 }
  99
 100 /* Wait for IOC to transition to a give state */
 101 static int
 102 mpt_wait_state(mpt_softc_t *mpt, enum DB_STATE_BITS state)
 103 {
 104         int i;
 105
 106         for (i = 0; i < MPT_MAX_WAIT; i++) {
 107                 u_int32_t db = mpt_rd_db(mpt);
 108                 if (MPT_STATE(db) == state) {
 109                         maxwait_state = i > maxwait_state ? i : maxwait_state;
 110                         return (MPT_OK);
 111                 }
 112                 DELAY(100);
 113         }
 114         return (MPT_FAIL);
 115 }
 116
 117
 118 /* Issue the reset COMMAND to the IOC */
 119 int
 120 mpt_soft_reset(mpt_softc_t *mpt)
 121 {
 122         if (mpt->verbose) {
 123                 device_printf(mpt->dev,"soft reset\n");
 124         }
 125
 126         /* Have to use hard reset if we are not in Running state */
 127         if (MPT_STATE(mpt_rd_db(mpt)) != MPT_DB_STATE_RUNNING) {
 128                 device_printf(mpt->dev,
 129                     "soft reset failed: device not running\n");
 130                 return MPT_FAIL;
 131         }
 132
 133         /* If door bell is in use we don't have a chance of getting
 134          * a word in since the IOC probably crashed in message
 135          * processing. So don't waste our time.
 136          */
 137         if (MPT_DB_IS_IN_USE(mpt_rd_db(mpt))) {
 138                 device_printf(mpt->dev, "soft reset failed: doorbell wedged\n");
 139                 return MPT_FAIL;
 140         }
 141
 142         /* Send the reset request to the IOC */
 143         mpt_write(mpt, MPT_OFFSET_DOORBELL,
 144             MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET << MPI_DOORBELL_FUNCTION_SHIFT);
 145         if (mpt_wait_db_ack(mpt) != MPT_OK) {
 146                 device_printf(mpt->dev, "soft reset failed: ack timeout\n");
 147                 return MPT_FAIL;
 148         }
 149
 150         /* Wait for the IOC to reload and come out of reset state */
 151         if (mpt_wait_state(mpt, MPT_DB_STATE_READY) != MPT_OK) {
 152                 device_printf(mpt->dev,
 153                     "soft reset failed: device did not start running\n");
 154                 return MPT_FAIL;
 155         }
 156
 157         return MPT_OK;
 158 }
 159
 160 /* This is a magic diagnostic reset that resets all the ARM
 161  * processors in the chip.
 162  */
 163 void
 164 mpt_hard_reset(mpt_softc_t *mpt)
 165 {
 166         /* This extra read comes for the Linux source
 167          * released by LSI. It's function is undocumented!
 168          */
 169         if (mpt->verbose) {
 170                 device_printf(mpt->dev, "hard reset\n");
 171         }
 172         mpt_read(mpt, MPT_OFFSET_FUBAR);
 173
 174         /* Enable diagnostic registers */
 175         mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPT_DIAG_SEQUENCE_1);
 176         mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPT_DIAG_SEQUENCE_2);
 177         mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPT_DIAG_SEQUENCE_3);
 178         mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPT_DIAG_SEQUENCE_4);
 179         mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPT_DIAG_SEQUENCE_5);
 180
 181         /* Diag. port is now active so we can now hit the reset bit */
 182         mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, MPT_DIAG_RESET_IOC);
 183
 184         DELAY(10000);
 185
 186         /* Disable Diagnostic Register */
 187         mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFF);
 188
 189         /* Restore the config register values */
 190         /*   Hard resets are known to screw up the BAR for diagnostic
 191              memory accesses (Mem1). */
 192         mpt_set_config_regs(mpt);
 193         if (mpt->mpt2 != NULL) {
 194                 mpt_set_config_regs(mpt->mpt2);
 195         }
 196
 197         /* Note that if there is no valid firmware to run, the doorbell will
 198            remain in the reset state (0x00000000) */
 199 }
 200
 201 /*
 202  * Reset the IOC when needed. Try software command first then if needed
 203  * poke at the magic diagnostic reset. Note that a hard reset resets
 204  * *both* IOCs on dual function chips (FC929 && LSI1030) as well as
 205  * fouls up the PCI configuration registers.
 206  */
 207 int
 208 mpt_reset(mpt_softc_t *mpt)
 209 {
 210         int ret;
 211
 212         /* Try a soft reset */
 213         if ((ret = mpt_soft_reset(mpt)) != MPT_OK) {
 214                 /* Failed; do a hard reset */
 215                 mpt_hard_reset(mpt);
 216
 217                 /* Wait for the IOC to reload and come out of reset state */
 218                 ret = mpt_wait_state(mpt, MPT_DB_STATE_READY);
 219                 if (ret != MPT_OK) {
 220                         device_printf(mpt->dev, "failed to reset device\n");
 221                 }
 222         }
 223
 224         return ret;
 225 }
 226
 227 /* Return a command buffer to the free queue */
 228 void
 229 mpt_free_request(mpt_softc_t *mpt, request_t *req)
 230 {
 231         if (req == NULL || req != &mpt->request_pool[req->index]) {
 232                 panic("mpt_free_request bad req ptr\n");
 233                 return;
 234         }
 235         callout_stop(&req->timeout);
 236         req->sequence = 0;
 237         req->ccb = NULL;
 238         req->debug = REQ_FREE;
 239         SLIST_INSERT_HEAD(&mpt->request_free_list, req, link);
 240 }
 241
 242 /* Get a command buffer from the free queue */
 243 request_t *
 244 mpt_get_request(mpt_softc_t *mpt)
 245 {
 246         request_t *req;
 247         req = SLIST_FIRST(&mpt->request_free_list);
 248         if (req != NULL) {
 249                 if (req != &mpt->request_pool[req->index]) {
 250                         panic("mpt_get_request: corrupted request free list\n");
 251                 }
 252                 if (req->ccb != NULL) {
 253                         panic("mpt_get_request: corrupted request free list (ccb)\n");
 254                 }
 255                 SLIST_REMOVE_HEAD(&mpt->request_free_list, link);
 256                 req->debug = REQ_IN_PROGRESS;
 257         }
 258         return req;
 259 }
 260
 261 /* Pass the command to the IOC */
 262 void
 263 mpt_send_cmd(mpt_softc_t *mpt, request_t *req)
 264 {
 265         req->sequence = mpt->sequence++;
 266         if (mpt->verbose > 1) {
 267                 u_int32_t *pReq;
 268                 pReq = req->req_vbuf;
 269                 device_printf(mpt->dev, "Send Request %d (0x%lx):\n",
 270                     req->index, (long) req->req_pbuf);
 271                 device_printf(mpt->dev, "%08X %08X %08X %08X\n",
 272                     pReq[0], pReq[1], pReq[2], pReq[3]);
 273                 device_printf(mpt->dev, "%08X %08X %08X %08X\n",
 274                     pReq[4], pReq[5], pReq[6], pReq[7]);
 275                 device_printf(mpt->dev, "%08X %08X %08X %08X\n",
 276                     pReq[8], pReq[9], pReq[10], pReq[11]);
 277                 device_printf(mpt->dev, "%08X %08X %08X %08X\n",
 278                     pReq[12], pReq[13], pReq[14], pReq[15]);
 279         }
 280         bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap,
 281            BUS_DMASYNC_PREWRITE);
 282         req->debug = REQ_ON_CHIP;
 283         mpt_write(mpt, MPT_OFFSET_REQUEST_Q, (u_int32_t) req->req_pbuf);
 284 }
 285
 286 /*
 287  * Give the reply buffer back to the IOC after we have
 288  * finished processing it.
 289  */
 290 void
 291 mpt_free_reply(mpt_softc_t *mpt, u_int32_t ptr)
 292 {
 293      mpt_write(mpt, MPT_OFFSET_REPLY_Q, ptr);
 294 }
 295
 296 /* Get a reply from the IOC */
 297 u_int32_t
 298 mpt_pop_reply_queue(mpt_softc_t *mpt)
 299 {
 300      return mpt_read(mpt, MPT_OFFSET_REPLY_Q);
 301 }
 302
 303 /*
 304  * Send a command to the IOC via the handshake register.
 305  *
 306  * Only done at initialization time and for certain unusual
 307  * commands such as device/bus reset as specified by LSI.
 308  */
 309 int
 310 mpt_send_handshake_cmd(mpt_softc_t *mpt, size_t len, void *cmd)
 311 {
 312         int i;
 313         u_int32_t data, *data32;
 314
 315         /* Check condition of the IOC */
 316         data = mpt_rd_db(mpt);
 317         if (((MPT_STATE(data) != MPT_DB_STATE_READY)    &&
 318              (MPT_STATE(data) != MPT_DB_STATE_RUNNING)  &&
 319              (MPT_STATE(data) != MPT_DB_STATE_FAULT))   ||
 320             (  MPT_DB_IS_IN_USE(data) )) {
 321                 device_printf(mpt->dev,
 322                     "handshake aborted due to invalid doorbell state\n");
 323                 mpt_print_db(data);
 324                 return(EBUSY);
 325         }
 326
 327         /* We move things in 32 bit chunks */
 328         len = (len + 3) >> 2;
 329         data32 = cmd;
 330
 331         /* Clear any left over pending doorbell interupts */
 332         if (MPT_DB_INTR(mpt_rd_intr(mpt)))
 333                 mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
 334
 335         /*
 336          * Tell the handshake reg. we are going to send a command
 337          * and how long it is going to be.
 338          */
 339         data = (MPI_FUNCTION_HANDSHAKE << MPI_DOORBELL_FUNCTION_SHIFT) |
 340             (len << MPI_DOORBELL_ADD_DWORDS_SHIFT);
 341         mpt_write(mpt, MPT_OFFSET_DOORBELL, data);
 342
 343         /* Wait for the chip to notice */
 344         if (mpt_wait_db_int(mpt) != MPT_OK) {
 345                 device_printf(mpt->dev, "mpt_send_handshake_cmd timeout1!\n");
 346                 return ETIMEDOUT;
 347         }
 348
 349         /* Clear the interrupt */
 350         mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
 351
 352         if (mpt_wait_db_ack(mpt) != MPT_OK) {
 353                 device_printf(mpt->dev, "mpt_send_handshake_cmd timeout2!\n");
 354                 return ETIMEDOUT;
 355         }
 356
 357         /* Send the command */
 358         for (i = 0; i < len; i++) {
 359                 mpt_write(mpt, MPT_OFFSET_DOORBELL, *data32++);
 360                 if (mpt_wait_db_ack(mpt) != MPT_OK) {
 361                         device_printf(mpt->dev,
 362                             "mpt_send_handshake_cmd timeout! index = %d\n", i);
 363                         return ETIMEDOUT;
 364                 }
 365         }
 366         return MPT_OK;
 367 }
 368
 369 /* Get the response from the handshake register */
 370 int
 371 mpt_recv_handshake_reply(mpt_softc_t *mpt, size_t reply_len, void *reply)
 372 {
 373         int left, reply_left;
 374         u_int16_t *data16;
 375         MSG_DEFAULT_REPLY *hdr;
 376
 377         /* We move things out in 16 bit chunks */
 378         reply_len >>= 1;
 379         data16 = (u_int16_t *)reply;
 380
 381         hdr = (MSG_DEFAULT_REPLY *)reply;
 382
 383         /* Get first word */
 384         if (mpt_wait_db_int(mpt) != MPT_OK) {
 385                 device_printf(mpt->dev, "mpt_recv_handshake_cmd timeout1!\n");
 386                 return ETIMEDOUT;
 387         }
 388         *data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK;
 389         mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
 390
 391         /* Get Second Word */
 392         if (mpt_wait_db_int(mpt) != MPT_OK) {
 393                 device_printf(mpt->dev, "mpt_recv_handshake_cmd timeout2!\n");
 394                 return ETIMEDOUT;
 395         }
 396         *data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK;
 397         mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
 398
 399         /* With the second word, we can now look at the length */
 400         if (mpt->verbose > 1 && ((reply_len >> 1) != hdr->MsgLength)) {
 401                 device_printf(mpt->dev,
 402                         "reply length does not match message length: "
 403                         "got 0x%02x, expected 0x%02lx\n",
 404                         hdr->MsgLength << 2, (long) (reply_len << 1));
 405         }
 406
 407         /* Get rest of the reply; but don't overflow the provided buffer */
 408         left = (hdr->MsgLength << 1) - 2;
 409         reply_left =  reply_len - 2;
 410         while (left--) {
 411                 u_int16_t datum;
 412
 413                 if (mpt_wait_db_int(mpt) != MPT_OK) {
 414                         device_printf(mpt->dev,
 415                             "mpt_recv_handshake_cmd timeout3!\n");
 416                         return ETIMEDOUT;
 417                 }
 418                 datum = mpt_read(mpt, MPT_OFFSET_DOORBELL);
 419
 420                 if (reply_left-- > 0)
 421                         *data16++ = datum & MPT_DB_DATA_MASK;
 422
 423                 mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
 424         }
 425
 426         /* One more wait & clear at the end */
 427         if (mpt_wait_db_int(mpt) != MPT_OK) {
 428                 device_printf(mpt->dev, "mpt_recv_handshake_cmd timeout4!\n");
 429                 return ETIMEDOUT;
 430         }
 431         mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
 432
 433         if ((hdr->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
 434                 if (mpt->verbose > 1)
 435                         mpt_print_reply(hdr);
 436                 return (MPT_FAIL | hdr->IOCStatus);
 437         }
 438
 439         return (0);
 440 }
 441
 442 static int
 443 mpt_get_iocfacts(mpt_softc_t *mpt, MSG_IOC_FACTS_REPLY *freplp)
 444 {
 445         MSG_IOC_FACTS f_req;
 446         int error;
 447
 448         bzero(&f_req, sizeof f_req);
 449         f_req.Function = MPI_FUNCTION_IOC_FACTS;
 450         f_req.MsgContext =  0x12071942;
 451         error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req);
 452         if (error)
 453                 return(error);
 454         error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp);
 455         return (error);
 456 }
 457
 458 static int
 459 mpt_get_portfacts(mpt_softc_t *mpt, MSG_PORT_FACTS_REPLY *freplp)
 460 {
 461         MSG_PORT_FACTS f_req;
 462         int error;
 463
 464         /* XXX: Only getting PORT FACTS for Port 0 */
 465         bzero(&f_req, sizeof f_req);
 466         f_req.Function = MPI_FUNCTION_PORT_FACTS;
 467         f_req.MsgContext =  0x12071943;
 468         error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req);
 469         if (error)
 470                 return(error);
 471         error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp);
 472         return (error);
 473 }
 474
 475 /*
 476  * Send the initialization request. This is where we specify how many
 477  * SCSI busses and how many devices per bus we wish to emulate.
 478  * This is also the command that specifies the max size of the reply
 479  * frames from the IOC that we will be allocating.
 480  */
 481 static int
 482 mpt_send_ioc_init(mpt_softc_t *mpt, u_int32_t who)
 483 {
 484         int error = 0;
 485         MSG_IOC_INIT init;
 486         MSG_IOC_INIT_REPLY reply;
 487
 488         bzero(&init, sizeof init);
 489         init.WhoInit = who;
 490         init.Function = MPI_FUNCTION_IOC_INIT;
 491         if (mpt->is_fc) {
 492                 init.MaxDevices = 255;
 493         } else {
 494                 init.MaxDevices = 16;
 495         }
 496         init.MaxBuses = 1;
 497         init.ReplyFrameSize = MPT_REPLY_SIZE;
 498         init.MsgContext = 0x12071941;
 499
 500         if ((error = mpt_send_handshake_cmd(mpt, sizeof init, &init)) != 0) {
 501                 return(error);
 502         }
 503
 504         error = mpt_recv_handshake_reply(mpt, sizeof reply, &reply);
 505         return (error);
 506 }
 507
 508
 509 /*
 510  * Utiltity routine to read configuration headers and pages
 511  */
 512
 513 static int
 514 mpt_read_cfg_header(mpt_softc_t *, int, int, int, fCONFIG_PAGE_HEADER *);
 515
 516 static int
 517 mpt_read_cfg_header(mpt_softc_t *mpt, int PageType, int PageNumber,
 518     int PageAddress, fCONFIG_PAGE_HEADER *rslt)
 519 {
 520         int count;
 521         request_t *req;
 522         MSG_CONFIG *cfgp;
 523         MSG_CONFIG_REPLY *reply;
 524
 525         req = mpt_get_request(mpt);
 526
 527         cfgp = req->req_vbuf;
 528         bzero(cfgp, sizeof *cfgp);
 529
 530         cfgp->Action = MPI_CONFIG_ACTION_PAGE_HEADER;
 531         cfgp->Function = MPI_FUNCTION_CONFIG;
 532         cfgp->Header.PageNumber = (U8) PageNumber;
 533         cfgp->Header.PageType = (U8) PageType;
 534         cfgp->PageAddress = PageAddress;
 535         MPI_pSGE_SET_FLAGS(((SGE_SIMPLE32 *) &cfgp->PageBufferSGE),
 536             (MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER |
 537             MPI_SGE_FLAGS_SIMPLE_ELEMENT | MPI_SGE_FLAGS_END_OF_LIST));
 538         cfgp->MsgContext = req->index | 0x80000000;
 539
 540         mpt_check_doorbell(mpt);
 541         mpt_send_cmd(mpt, req);
 542         count = 0;
 543         do {
 544                 DELAY(500);
 545                 mpt_intr(mpt);
 546                 if (++count == 1000) {
 547                         device_printf(mpt->dev, "read_cfg_header timed out\n");
 548                         return (-1);
 549                 }
 550         } while (req->debug == REQ_ON_CHIP);
 551
 552         reply = (MSG_CONFIG_REPLY *) MPT_REPLY_PTOV(mpt, req->sequence);
 553         if ((reply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
 554                 device_printf(mpt->dev,
 555                     "mpt_read_cfg_header: Config Info Status %x\n",
 556                     reply->IOCStatus);
 557                 mpt_free_reply(mpt, (req->sequence << 1));
 558                 return (-1);
 559         }
 560         bcopy(&reply->Header, rslt, sizeof (fCONFIG_PAGE_HEADER));
 561         mpt_free_reply(mpt, (req->sequence << 1));
 562         mpt_free_request(mpt, req);
 563         return (0);
 564 }
 565
 566 #define CFG_DATA_OFF    128
 567
 568 int
 569 mpt_read_cfg_page(mpt_softc_t *mpt, int PageAddress, fCONFIG_PAGE_HEADER *hdr)
 570 {
 571         int count;
 572         request_t *req;
 573         SGE_SIMPLE32 *se;
 574         MSG_CONFIG *cfgp;
 575         size_t amt;
 576         MSG_CONFIG_REPLY *reply;
 577
 578         req = mpt_get_request(mpt);
 579
 580         cfgp = req->req_vbuf;
 581         bzero(cfgp, MPT_REQUEST_AREA);
 582         cfgp->Action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 583         cfgp->Function = MPI_FUNCTION_CONFIG;
 584         cfgp->Header = *hdr;
 585         amt = (cfgp->Header.PageLength * sizeof (u_int32_t));
 586         cfgp->Header.PageType &= MPI_CONFIG_PAGETYPE_MASK;
 587         cfgp->PageAddress = PageAddress;
 588         se = (SGE_SIMPLE32 *) &cfgp->PageBufferSGE;
 589         se->Address = req->req_pbuf + CFG_DATA_OFF;
 590         MPI_pSGE_SET_LENGTH(se, amt);
 591         MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
 592             MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER |
 593             MPI_SGE_FLAGS_END_OF_LIST));
 594
 595         cfgp->MsgContext = req->index | 0x80000000;
 596
 597         mpt_check_doorbell(mpt);
 598         mpt_send_cmd(mpt, req);
 599         count = 0;
 600         do {
 601                 DELAY(500);
 602                 mpt_intr(mpt);
 603                 if (++count == 1000) {
 604                         device_printf(mpt->dev, "read_cfg_page timed out\n");
 605                         return (-1);
 606                 }
 607         } while (req->debug == REQ_ON_CHIP);
 608
 609         reply = (MSG_CONFIG_REPLY *) MPT_REPLY_PTOV(mpt, req->sequence);
 610         if ((reply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
 611                 device_printf(mpt->dev,
 612                     "mpt_read_cfg_page: Config Info Status %x\n",
 613                     reply->IOCStatus);
 614                 mpt_free_reply(mpt, (req->sequence << 1));
 615                 return (-1);
 616         }
 617         mpt_free_reply(mpt, (req->sequence << 1));
 618         bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap,
 619             BUS_DMASYNC_POSTREAD);
 620         if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_PORT &&
 621             cfgp->Header.PageNumber == 0) {
 622                 amt = sizeof (fCONFIG_PAGE_SCSI_PORT_0);
 623         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_PORT &&
 624             cfgp->Header.PageNumber == 1) {
 625                 amt = sizeof (fCONFIG_PAGE_SCSI_PORT_1);
 626         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_PORT &&
 627             cfgp->Header.PageNumber == 2) {
 628                 amt = sizeof (fCONFIG_PAGE_SCSI_PORT_2);
 629         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_DEVICE  &&
 630             cfgp->Header.PageNumber == 0) {
 631                 amt = sizeof (fCONFIG_PAGE_SCSI_DEVICE_0);
 632         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_DEVICE  &&
 633             cfgp->Header.PageNumber == 1) {
 634                 amt = sizeof (fCONFIG_PAGE_SCSI_DEVICE_1);
 635         }
 636         bcopy(((caddr_t)req->req_vbuf)+CFG_DATA_OFF, hdr, amt);
 637         mpt_free_request(mpt, req);
 638         return (0);
 639 }
 640
 641 int
 642 mpt_write_cfg_page(mpt_softc_t *mpt, int PageAddress, fCONFIG_PAGE_HEADER *hdr)
 643 {
 644         int count, hdr_attr;
 645         request_t *req;
 646         SGE_SIMPLE32 *se;
 647         MSG_CONFIG *cfgp;
 648         size_t amt;
 649         MSG_CONFIG_REPLY *reply;
 650
 651         req = mpt_get_request(mpt);
 652
 653         cfgp = req->req_vbuf;
 654         bzero(cfgp, sizeof *cfgp);
 655
 656         hdr_attr = hdr->PageType & MPI_CONFIG_PAGEATTR_MASK;
 657         if (hdr_attr != MPI_CONFIG_PAGEATTR_CHANGEABLE &&
 658             hdr_attr != MPI_CONFIG_PAGEATTR_PERSISTENT) {
 659                 device_printf(mpt->dev, "page type 0x%x not changeable\n",
 660                     hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
 661                 return (-1);
 662         }
 663         hdr->PageType &= MPI_CONFIG_PAGETYPE_MASK;
 664
 665         cfgp->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 666         cfgp->Function = MPI_FUNCTION_CONFIG;
 667         cfgp->Header = *hdr;
 668         amt = (cfgp->Header.PageLength * sizeof (u_int32_t));
 669         cfgp->PageAddress = PageAddress;
 670
 671         se = (SGE_SIMPLE32 *) &cfgp->PageBufferSGE;
 672         se->Address = req->req_pbuf + CFG_DATA_OFF;
 673         MPI_pSGE_SET_LENGTH(se, amt);
 674         MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
 675             MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER |
 676             MPI_SGE_FLAGS_END_OF_LIST | MPI_SGE_FLAGS_HOST_TO_IOC));
 677
 678         cfgp->MsgContext = req->index | 0x80000000;
 679
 680         if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_PORT &&
 681             cfgp->Header.PageNumber == 0) {
 682                 amt = sizeof (fCONFIG_PAGE_SCSI_PORT_0);
 683         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_PORT &&
 684             cfgp->Header.PageNumber == 1) {
 685                 amt = sizeof (fCONFIG_PAGE_SCSI_PORT_1);
 686         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_PORT &&
 687             cfgp->Header.PageNumber == 2) {
 688                 amt = sizeof (fCONFIG_PAGE_SCSI_PORT_2);
 689         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_DEVICE  &&
 690             cfgp->Header.PageNumber == 0) {
 691                 amt = sizeof (fCONFIG_PAGE_SCSI_DEVICE_0);
 692         } else if (cfgp->Header.PageType == MPI_CONFIG_PAGETYPE_SCSI_DEVICE  &&
 693             cfgp->Header.PageNumber == 1) {
 694                 amt = sizeof (fCONFIG_PAGE_SCSI_DEVICE_1);
 695         }
 696         bcopy(hdr, ((caddr_t)req->req_vbuf)+CFG_DATA_OFF, amt);
 697         /* Restore stripped out attributes */
 698         hdr->PageType |= hdr_attr;
 699
 700         mpt_check_doorbell(mpt);
 701         mpt_send_cmd(mpt, req);
 702         count = 0;
 703         do {
 704                 DELAY(500);
 705                 mpt_intr(mpt);
 706                 if (++count == 1000) {
 707                         hdr->PageType |= hdr_attr;
 708                         device_printf(mpt->dev,
 709                             "mpt_write_cfg_page timed out\n");
 710                         return (-1);
 711                 }
 712         } while (req->debug == REQ_ON_CHIP);
 713
 714         reply = (MSG_CONFIG_REPLY *) MPT_REPLY_PTOV(mpt, req->sequence);
 715         if ((reply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
 716                 device_printf(mpt->dev,
 717                     "mpt_write_cfg_page: Config Info Status %x\n",
 718                     reply->IOCStatus);
 719                 mpt_free_reply(mpt, (req->sequence << 1));
 720                 return (-1);
 721         }
 722         mpt_free_reply(mpt, (req->sequence << 1));
 723
 724         mpt_free_request(mpt, req);
 725         return (0);
 726 }
 727
 728 /*
 729  * Read SCSI configuration information
 730  */
 731 static int
 732 mpt_read_config_info_spi(mpt_softc_t *mpt)
 733 {
 734         int rv, i;
 735
 736         rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_SCSI_PORT, 0,
 737             0, &mpt->mpt_port_page0.Header);
 738         if (rv) {
 739                 return (-1);
 740         }
 741         if (mpt->verbose > 1) {
 742                 device_printf(mpt->dev, "SPI Port Page 0 Header: %x %x %x %x\n",
 743                     mpt->mpt_port_page0.Header.PageVersion,
 744                     mpt->mpt_port_page0.Header.PageLength,
 745                     mpt->mpt_port_page0.Header.PageNumber,
 746                     mpt->mpt_port_page0.Header.PageType);
 747         }
 748
 749         rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_SCSI_PORT, 1,
 750             0, &mpt->mpt_port_page1.Header);
 751         if (rv) {
 752                 return (-1);
 753         }
 754         if (mpt->verbose > 1) {
 755                 device_printf(mpt->dev, "SPI Port Page 1 Header: %x %x %x %x\n",
 756                     mpt->mpt_port_page1.Header.PageVersion,
 757                     mpt->mpt_port_page1.Header.PageLength,
 758                     mpt->mpt_port_page1.Header.PageNumber,
 759                     mpt->mpt_port_page1.Header.PageType);
 760         }
 761
 762         rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_SCSI_PORT, 2,
 763             0, &mpt->mpt_port_page2.Header);
 764         if (rv) {
 765                 return (-1);
 766         }
 767
 768         if (mpt->verbose > 1) {
 769                 device_printf(mpt->dev, "SPI Port Page 2 Header: %x %x %x %x\n",
 770                     mpt->mpt_port_page1.Header.PageVersion,
 771                     mpt->mpt_port_page1.Header.PageLength,
 772                     mpt->mpt_port_page1.Header.PageNumber,
 773                     mpt->mpt_port_page1.Header.PageType);
 774         }
 775
 776         for (i = 0; i < 16; i++) {
 777                 rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_SCSI_DEVICE,
 778                     0, i, &mpt->mpt_dev_page0[i].Header);
 779                 if (rv) {
 780                         return (-1);
 781                 }
 782                 if (mpt->verbose > 1) {
 783                         device_printf(mpt->dev,
 784                             "SPI Target %d Device Page 0 Header: %x %x %x %x\n",
 785                             i, mpt->mpt_dev_page0[i].Header.PageVersion,
 786                             mpt->mpt_dev_page0[i].Header.PageLength,
 787                             mpt->mpt_dev_page0[i].Header.PageNumber,
 788                             mpt->mpt_dev_page0[i].Header.PageType);
 789                 }
 790
 791                 rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_SCSI_DEVICE,
 792                     1, i, &mpt->mpt_dev_page1[i].Header);
 793                 if (rv) {
 794                         return (-1);
 795                 }
 796                 if (mpt->verbose > 1) {
 797                         device_printf(mpt->dev,
 798                             "SPI Target %d Device Page 1 Header: %x %x %x %x\n",
 799                             i, mpt->mpt_dev_page1[i].Header.PageVersion,
 800                             mpt->mpt_dev_page1[i].Header.PageLength,
 801                             mpt->mpt_dev_page1[i].Header.PageNumber,
 802                             mpt->mpt_dev_page1[i].Header.PageType);
 803                 }
 804         }
 805
 806         /*
 807          * At this point, we don't *have* to fail. As long as we have
 808          * valid config header information, we can (barely) lurch
 809          * along.
 810          */
 811
 812         rv = mpt_read_cfg_page(mpt, 0, &mpt->mpt_port_page0.Header);
 813         if (rv) {
 814                 device_printf(mpt->dev, "failed to read SPI Port Page 0\n");
 815         } else if (mpt->verbose > 1) {
 816                 device_printf(mpt->dev,
 817                     "SPI Port Page 0: Capabilities %x PhysicalInterface %x\n",
 818                     mpt->mpt_port_page0.Capabilities,
 819                     mpt->mpt_port_page0.PhysicalInterface);
 820         }
 821
 822         rv = mpt_read_cfg_page(mpt, 0, &mpt->mpt_port_page1.Header);
 823         if (rv) {
 824                 device_printf(mpt->dev, "failed to read SPI Port Page 1\n");
 825         } else if (mpt->verbose > 1) {
 826                 device_printf(mpt->dev,
 827                     "SPI Port Page 1: Configuration %x OnBusTimerValue %x\n",
 828                     mpt->mpt_port_page1.Configuration,
 829                     mpt->mpt_port_page1.OnBusTimerValue);
 830         }
 831
 832         rv = mpt_read_cfg_page(mpt, 0, &mpt->mpt_port_page2.Header);
 833         if (rv) {
 834                 device_printf(mpt->dev, "failed to read SPI Port Page 2\n");
 835         } else if (mpt->verbose > 1) {
 836                 device_printf(mpt->dev,
 837                     "SPI Port Page 2: Flags %x Settings %x\n",
 838                     mpt->mpt_port_page2.PortFlags,
 839                     mpt->mpt_port_page2.PortSettings);
 840                 for (i = 0; i < 16; i++) {
 841                         device_printf(mpt->dev,
 842                             "SPI Port Page 2 Tgt %d: timo %x SF %x Flags %x\n",
 843                             i, mpt->mpt_port_page2.DeviceSettings[i].Timeout,
 844                             mpt->mpt_port_page2.DeviceSettings[i].SyncFactor,
 845                             mpt->mpt_port_page2.DeviceSettings[i].DeviceFlags);
 846                 }
 847         }
 848
 849         for (i = 0; i < 16; i++) {
 850                 rv = mpt_read_cfg_page(mpt, i, &mpt->mpt_dev_page0[i].Header);
 851                 if (rv) {
 852                         device_printf(mpt->dev,
 853                             "cannot read SPI Tgt %d Device Page 0\n", i);
 854                         continue;
 855                 }
 856                 if (mpt->verbose > 1) {
 857                         device_printf(mpt->dev,
 858                             "SPI Tgt %d Page 0: NParms %x Information %x\n",
 859                             i, mpt->mpt_dev_page0[i].NegotiatedParameters,
 860                             mpt->mpt_dev_page0[i].Information);
 861                 }
 862                 rv = mpt_read_cfg_page(mpt, i, &mpt->mpt_dev_page1[i].Header);
 863                 if (rv) {
 864                         device_printf(mpt->dev,
 865                             "cannot read SPI Tgt %d Device Page 1\n", i);
 866                         continue;
 867                 }
 868                 if (mpt->verbose > 1) {
 869                         device_printf(mpt->dev,
 870                             "SPI Tgt %d Page 1: RParms %x Configuration %x\n",
 871                             i, mpt->mpt_dev_page1[i].RequestedParameters,
 872                             mpt->mpt_dev_page1[i].Configuration);
 873                 }
 874         }
 875         return (0);
 876 }
 877
 878 /*
 879  * Validate SPI configuration information.
 880  *
 881  * In particular, validate SPI Port Page 1.
 882  */
 883 static int
 884 mpt_set_initial_config_spi(mpt_softc_t *mpt)
 885 {
 886         int i, pp1val = ((1 << mpt->mpt_ini_id) << 16) | mpt->mpt_ini_id;
 887
 888         mpt->mpt_disc_enable = 0xff;
 889         mpt->mpt_tag_enable = 0;
 890
 891         if (mpt->mpt_port_page1.Configuration != pp1val) {
 892                 fCONFIG_PAGE_SCSI_PORT_1 tmp;
 893                 device_printf(mpt->dev,
 894                     "SPI Port Page 1 Config value bad (%x)- should be %x\n",
 895                     mpt->mpt_port_page1.Configuration, pp1val);
 896                 tmp = mpt->mpt_port_page1;
 897                 tmp.Configuration = pp1val;
 898                 if (mpt_write_cfg_page(mpt, 0, &tmp.Header)) {
 899                         return (-1);
 900                 }
 901                 if (mpt_read_cfg_page(mpt, 0, &tmp.Header)) {
 902                         return (-1);
 903                 }
 904                 if (tmp.Configuration != pp1val) {
 905                         device_printf(mpt->dev,
 906                             "failed to reset SPI Port Page 1 Config value\n");
 907                         return (-1);
 908                 }
 909                 mpt->mpt_port_page1 = tmp;
 910         }
 911
 912         for (i = 0; i < 16; i++) {
 913                 fCONFIG_PAGE_SCSI_DEVICE_1 tmp;
 914                 tmp = mpt->mpt_dev_page1[i];
 915                 tmp.RequestedParameters = 0;
 916                 tmp.Configuration = 0;
 917                 if (mpt->verbose > 1) {
 918                         device_printf(mpt->dev,
 919                             "Set Tgt %d SPI DevicePage 1 values to %x 0 %x\n",
 920                             i, tmp.RequestedParameters, tmp.Configuration);
 921                 }
 922                 if (mpt_write_cfg_page(mpt, i, &tmp.Header)) {
 923                         return (-1);
 924                 }
 925                 if (mpt_read_cfg_page(mpt, i, &tmp.Header)) {
 926                         return (-1);
 927                 }
 928                 mpt->mpt_dev_page1[i] = tmp;
 929                 if (mpt->verbose > 1) {
 930                         device_printf(mpt->dev,
 931                             "SPI Tgt %d Page 1: RParm %x Configuration %x\n", i,
 932                             mpt->mpt_dev_page1[i].RequestedParameters,
 933                             mpt->mpt_dev_page1[i].Configuration);
 934                 }
 935         }
 936         return (0);
 937 }
 938
 939 /*
 940  * Enable IOC port
 941  */
 942 static int
 943 mpt_send_port_enable(mpt_softc_t *mpt, int port)
 944 {
 945         int count;
 946         request_t *req;
 947         MSG_PORT_ENABLE *enable_req;
 948
 949         req = mpt_get_request(mpt);
 950
 951         enable_req = req->req_vbuf;
 952         bzero(enable_req, sizeof *enable_req);
 953
 954         enable_req->Function   = MPI_FUNCTION_PORT_ENABLE;
 955         enable_req->MsgContext = req->index | 0x80000000;
 956         enable_req->PortNumber = port;
 957
 958         mpt_check_doorbell(mpt);
 959         if (mpt->verbose > 1) {
 960                 device_printf(mpt->dev, "enabling port %d\n", port);
 961         }
 962         mpt_send_cmd(mpt, req);
 963
 964         count = 0;
 965         do {
 966                 DELAY(500);
 967                 mpt_intr(mpt);
 968                 if (++count == 100000) {
 969                         device_printf(mpt->dev, "port enable timed out\n");
 970                         return (-1);
 971                 }
 972         } while (req->debug == REQ_ON_CHIP);
 973         mpt_free_request(mpt, req);
 974         return (0);
 975 }
 976
 977 /*
 978  * Enable/Disable asynchronous event reporting.
 979  *
 980  * NB: this is the first command we send via shared memory
 981  * instead of the handshake register.
 982  */
 983 static int
 984 mpt_send_event_request(mpt_softc_t *mpt, int onoff)
 985 {
 986         request_t *req;
 987         MSG_EVENT_NOTIFY *enable_req;
 988
 989         req = mpt_get_request(mpt);
 990
 991         enable_req = req->req_vbuf;
 992         bzero(enable_req, sizeof *enable_req);
 993
 994         enable_req->Function   = MPI_FUNCTION_EVENT_NOTIFICATION;
 995         enable_req->MsgContext = req->index | 0x80000000;
 996         enable_req->Switch     = onoff;
 997
 998         mpt_check_doorbell(mpt);
 999         if (mpt->verbose > 1) {
1000                 device_printf(mpt->dev, "%sabling async events\n",
1001                     onoff? "en" : "dis");
1002         }
1003         mpt_send_cmd(mpt, req);
1004
1005         return (0);
1006 }
1007
1008 /*
1009  * Un-mask the interupts on the chip.
1010  */
1011 void
1012 mpt_enable_ints(mpt_softc_t *mpt)
1013 {
1014         /* Unmask every thing except door bell int */
1015         mpt_write(mpt, MPT_OFFSET_INTR_MASK, MPT_INTR_DB_MASK);
1016 }
1017
1018 /*
1019  * Mask the interupts on the chip.
1020  */
1021 void
1022 mpt_disable_ints(mpt_softc_t *mpt)
1023 {
1024         /* Mask all interrupts */
1025         mpt_write(mpt, MPT_OFFSET_INTR_MASK,
1026             MPT_INTR_REPLY_MASK | MPT_INTR_DB_MASK);
1027 }
1028
1029 /* (Re)Initialize the chip for use */
1030 int
1031 mpt_init(mpt_softc_t *mpt, u_int32_t who)
1032 {
1033         int try;
1034         MSG_IOC_FACTS_REPLY facts;
1035         MSG_PORT_FACTS_REPLY pfp;
1036         u_int32_t pptr;
1037         int val;
1038
1039         /* Put all request buffers (back) on the free list */
1040         SLIST_INIT(&mpt->request_free_list);
1041         for (val = 0; val < MPT_MAX_REQUESTS(mpt); val++) {
1042                 callout_init(&mpt->request_pool[val].timeout);
1043                 mpt_free_request(mpt, &mpt->request_pool[val]);
1044         }
1045
1046         if (mpt->verbose > 1) {
1047                 device_printf(mpt->dev, "doorbell req = %s\n",
1048                     mpt_ioc_diag(mpt_read(mpt, MPT_OFFSET_DOORBELL)));
1049         }
1050
1051         /*
1052          * Start by making sure we're not at FAULT or RESET state
1053          */
1054         switch (mpt_rd_db(mpt) & MPT_DB_STATE_MASK) {
1055         case MPT_DB_STATE_RESET:
1056         case MPT_DB_STATE_FAULT:
1057                 if (mpt_reset(mpt) != MPT_OK) {
1058                         return (EIO);
1059                 }
1060         default:
1061                 break;
1062         }
1063
1064         for (try = 0; try < MPT_MAX_TRYS; try++) {
1065                 /*
1066                  * No need to reset if the IOC is already in the READY state.
1067                  *
1068                  * Force reset if initialization failed previously.
1069                  * Note that a hard_reset of the second channel of a '929
1070                  * will stop operation of the first channel.  Hopefully, if the
1071                  * first channel is ok, the second will not require a hard
1072                  * reset.
1073                  */
1074                 if ((mpt_rd_db(mpt) & MPT_DB_STATE_MASK) !=
1075                     MPT_DB_STATE_READY) {
1076                         if (mpt_reset(mpt) != MPT_OK) {
1077                                 DELAY(10000);
1078                                 continue;
1079                         }
1080                 }
1081
1082                 if (mpt_get_iocfacts(mpt, &facts) != MPT_OK) {
1083                         device_printf(mpt->dev, "mpt_get_iocfacts failed\n");
1084                         continue;
1085                 }
1086
1087                 if (mpt->verbose > 1) {
1088                         device_printf(mpt->dev,
1089                             "IOCFACTS: GlobalCredits=%d BlockSize=%u "
1090                             "Request Frame Size %u\n", facts.GlobalCredits,
1091                             facts.BlockSize, facts.RequestFrameSize);
1092                 }
1093                 mpt->mpt_global_credits = facts.GlobalCredits;
1094                 mpt->request_frame_size = facts.RequestFrameSize;
1095
1096                 if (mpt_get_portfacts(mpt, &pfp) != MPT_OK) {
1097                         device_printf(mpt->dev, "mpt_get_portfacts failed\n");
1098                         continue;
1099                 }
1100
1101                 if (mpt->verbose > 1) {
1102                         device_printf(mpt->dev,
1103                             "PORTFACTS: Type %x PFlags %x IID %d MaxDev %d\n",
1104                             pfp.PortType, pfp.ProtocolFlags, pfp.PortSCSIID,
1105                             pfp.MaxDevices);
1106                 }
1107
1108                 if (pfp.PortType != MPI_PORTFACTS_PORTTYPE_SCSI &&
1109                     pfp.PortType != MPI_PORTFACTS_PORTTYPE_FC) {
1110                         device_printf(mpt->dev, "Unsupported Port Type (%x)\n",
1111                             pfp.PortType);
1112                         return (ENXIO);
1113                 }
1114                 if (!(pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR)) {
1115                         device_printf(mpt->dev, "initiator role unsupported\n");
1116                         return (ENXIO);
1117                 }
1118                 if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_FC) {
1119                         mpt->is_fc = 1;
1120                 } else {
1121                         mpt->is_fc = 0;
1122                 }
1123                 mpt->mpt_ini_id = pfp.PortSCSIID;
1124
1125                 if (mpt_send_ioc_init(mpt, who) != MPT_OK) {
1126                         device_printf(mpt->dev, "mpt_send_ioc_init failed\n");
1127                         continue;
1128                 }
1129
1130                 if (mpt->verbose > 1) {
1131                         device_printf(mpt->dev, "mpt_send_ioc_init ok\n");
1132                 }
1133
1134                 if (mpt_wait_state(mpt, MPT_DB_STATE_RUNNING) != MPT_OK) {
1135                         device_printf(mpt->dev,
1136                             "IOC failed to go to run state\n");
1137                         continue;
1138                 }
1139                 if (mpt->verbose > 1) {
1140                         device_printf(mpt->dev, "IOC now at RUNSTATE\n");
1141                 }
1142
1143                 /*
1144                  * Give it reply buffers
1145                  *
1146                  * Do *not* except global credits.
1147                  */
1148                 for (val = 0, pptr = mpt->reply_phys;
1149                     (pptr + MPT_REPLY_SIZE) < (mpt->reply_phys + PAGE_SIZE);
1150                      pptr += MPT_REPLY_SIZE) {
1151                         mpt_free_reply(mpt, pptr);
1152                         if (++val == mpt->mpt_global_credits - 1)
1153                                 break;
1154                 }
1155
1156                 /*
1157                  * Enable asynchronous event reporting
1158                  */
1159                 mpt_send_event_request(mpt, 1);
1160
1161
1162                 /*
1163                  * Read set up initial configuration information
1164                  * (SPI only for now)
1165                  */
1166
1167                 if (mpt->is_fc == 0) {
1168                         if (mpt_read_config_info_spi(mpt)) {
1169                                 return (EIO);
1170                         }
1171                         if (mpt_set_initial_config_spi(mpt)) {
1172                                 return (EIO);
1173                         }
1174                 }
1175
1176                 /*
1177                  * Now enable the port
1178                  */
1179                 if (mpt_send_port_enable(mpt, 0) != MPT_OK) {
1180                         device_printf(mpt->dev, "failed to enable port 0\n");
1181                         continue;
1182                 }
1183
1184                 if (mpt->verbose > 1) {
1185                         device_printf(mpt->dev, "enabled port 0\n");
1186                 }
1187
1188                 /* Everything worked */
1189                 break;
1190         }
1191
1192         if (try >= MPT_MAX_TRYS) {
1193                 device_printf(mpt->dev, "failed to initialize IOC\n");
1194                 return (EIO);
1195         }
1196
1197         if (mpt->verbose > 1) {
1198                 device_printf(mpt->dev, "enabling interrupts\n");
1199         }
1200
1201         mpt_enable_ints(mpt);
1202         return (0);
1203 }