sys/dev/raid/ips/ips.c

   1 /*-
   2  * Written by: David Jeffery
   3  * Copyright (c) 2002 Adaptec Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/sys/dev/ips/ips.c,v 1.12 2004/05/30 04:01:29 scottl Exp $
  28  * $DragonFly: src/sys/dev/raid/ips/ips.c,v 1.11 2005/06/07 00:51:13 y0netan1 Exp $
  29  */
  30
  31 #include <dev/raid/ips/ips.h>
  32 #include <sys/stat.h>
  33 #include <sys/time.h>
  34 #include <sys/thread2.h>
  35 #include <machine/clock.h>
  36
  37 static d_open_t ips_open;
  38 static d_close_t ips_close;
  39 static d_ioctl_t ips_ioctl;
  40
  41 MALLOC_DEFINE(M_IPSBUF, "ipsbuf", "IPS driver buffer");
  42
  43 static struct cdevsw ips_cdevsw = {
  44         .d_name         = "ips",
  45         .d_maj          = IPS_CDEV_MAJOR,
  46         .d_flags        = D_DISK,
  47         .d_port         = NULL,
  48         .d_clone        = NULL,
  49         .old_open       = ips_open,
  50         .old_close      = ips_close,
  51         .old_ioctl      = ips_ioctl,
  52 };
  53
  54 static const char *ips_adapter_name[] = {
  55         "N/A",
  56         "ServeRAID (copperhead)",
  57         "ServeRAID II (copperhead refresh)",
  58         "ServeRAID onboard (copperhead)",
  59         "ServeRAID onboard (copperhead)",
  60         "ServeRAID 3H (clarinet)",
  61         "ServeRAID 3L (clarinet lite)",
  62         "ServeRAID 4H (trombone)",
  63         "ServeRAID 4M (morpheus)",
  64         "ServeRAID 4L (morpheus lite)",
  65         "ServeRAID 4Mx (neo)",
  66         "ServeRAID 4Lx (neo lite)",
  67         "ServeRAID 5i II (sarasota)",
  68         "ServeRAID 5i (sarasota)",
  69         "ServeRAID 6M (marco)",
  70         "ServeRAID 6i (sebring)"
  71 };
  72
  73
  74 static int
  75 ips_open(dev_t dev, int flags, int fmt, d_thread_t *td)
  76 {
  77         ips_softc_t *sc = dev->si_drv1;
  78
  79         sc->state |= IPS_DEV_OPEN;
  80         return 0;
  81 }
  82
  83 static int
  84 ips_close(dev_t dev, int flags, int fmt, d_thread_t *td)
  85 {
  86         ips_softc_t *sc = dev->si_drv1;
  87
  88         sc->state &= ~IPS_DEV_OPEN;
  89         return 0;
  90 }
  91
  92 static int
  93 ips_ioctl(dev_t dev, u_long command, caddr_t addr, int32_t flags,
  94     d_thread_t *td)
  95 {
  96         ips_softc_t *sc;
  97
  98         sc = dev->si_drv1;
  99         return ips_ioctl_request(sc, command, addr, flags);
 100 }
 101
 102 static void
 103 ips_cmd_dmaload(void *cmdptr, bus_dma_segment_t *segments, int segnum,
 104     int error)
 105 {
 106         ips_command_t *command = cmdptr;
 107
 108         PRINTF(10, "ips: in ips_cmd_dmaload\n");
 109         if (!error)
 110                 command->command_phys_addr = segments[0].ds_addr;
 111
 112 }
 113
 114 /* is locking needed? what locking guarentees are there on removal? */
 115 static __inline__ int
 116 ips_cmdqueue_free(ips_softc_t *sc)
 117 {
 118         int i, error = -1;
 119         ips_command_t *command;
 120
 121         crit_enter();
 122         if (sc->used_commands == 0) {
 123                 for (i = 0; i < sc->max_cmds; i++) {
 124                         command = &sc->commandarray[i];
 125                         if (command->command_phys_addr == 0)
 126                                 continue;
 127                         bus_dmamap_unload(sc->command_dmatag,
 128                             command->command_dmamap);
 129                         bus_dmamem_free(sc->command_dmatag,
 130                             command->command_buffer,
 131                             command->command_dmamap);
 132                 }
 133                 error = 0;
 134                 sc->state |= IPS_OFFLINE;
 135         }
 136         crit_exit();
 137         return error;
 138 }
 139
 140 /* places all ips command structs on the free command queue.  No locking as if someone else tries
 141  * to access this during init, we have bigger problems */
 142 static __inline__ int
 143 ips_cmdqueue_init(ips_softc_t *sc)
 144 {
 145         int i;
 146         ips_command_t *command;
 147
 148         SLIST_INIT(&sc->free_cmd_list);
 149         STAILQ_INIT(&sc->cmd_wait_list);
 150         for (i = 0; i < sc->max_cmds; i++) {
 151                 command = &sc->commandarray[i];
 152                 command->id = i;
 153                 command->sc = sc;
 154                 if (bus_dmamem_alloc(sc->command_dmatag,
 155                     &command->command_buffer, BUS_DMA_NOWAIT,
 156                     &command->command_dmamap))
 157                         goto error;
 158                 bus_dmamap_load(sc->command_dmatag, command->command_dmamap,
 159                     command->command_buffer, IPS_COMMAND_LEN, ips_cmd_dmaload,
 160                     command, BUS_DMA_NOWAIT);
 161                 if (command->command_phys_addr == 0) {
 162                         bus_dmamem_free(sc->command_dmatag,
 163                             command->command_buffer, command->command_dmamap);
 164                         goto error;
 165                 }
 166                 SLIST_INSERT_HEAD(&sc->free_cmd_list, command, next);
 167         }
 168         sc->state &= ~IPS_OFFLINE;
 169         return 0;
 170 error:
 171         ips_cmdqueue_free(sc);
 172         return ENOMEM;
 173 }
 174
 175 static int
 176 ips_add_waiting_command(ips_softc_t *sc, int (*callback)(ips_command_t *),
 177     void *data)
 178 {
 179         ips_command_t *command;
 180         ips_wait_list_t *waiter;
 181
 182         waiter = malloc(sizeof(ips_wait_list_t), M_IPSBUF, M_INTWAIT);
 183         crit_enter();
 184         if (sc->state & IPS_OFFLINE) {
 185                 crit_exit();
 186                 free(waiter, M_IPSBUF);
 187                 return EIO;
 188         }
 189         command = SLIST_FIRST(&sc->free_cmd_list);
 190         if (command && !(sc->state & IPS_TIMEOUT)) {
 191                 SLIST_REMOVE_HEAD(&sc->free_cmd_list, next);
 192                 sc->used_commands++;
 193                 crit_exit();
 194                 clear_ips_command(command);
 195                 bzero(command->command_buffer, IPS_COMMAND_LEN);
 196                 free(waiter, M_IPSBUF);
 197                 command->arg = data;
 198                 return callback(command);
 199         }
 200         DEVICE_PRINTF(1, sc->dev, "adding command to the wait queue\n");
 201         waiter->callback = callback;
 202         waiter->data = data;
 203         STAILQ_INSERT_TAIL(&sc->cmd_wait_list, waiter, next);
 204         crit_exit();
 205         return 0;
 206 }
 207
 208 static void
 209 ips_run_waiting_command(ips_softc_t *sc)
 210 {
 211         ips_wait_list_t *waiter;
 212         ips_command_t   *command;
 213         int (*callback)(ips_command_t*);
 214
 215         crit_enter();
 216         waiter = STAILQ_FIRST(&sc->cmd_wait_list);
 217         command = SLIST_FIRST(&sc->free_cmd_list);
 218         if (waiter == NULL || command == NULL) {
 219                 crit_exit();
 220                 return;
 221         }
 222         DEVICE_PRINTF(1, sc->dev, "removing command from wait queue\n");
 223         SLIST_REMOVE_HEAD(&sc->free_cmd_list, next);
 224         STAILQ_REMOVE_HEAD(&sc->cmd_wait_list, next);
 225         sc->used_commands++;
 226         crit_exit();
 227         clear_ips_command(command);
 228         bzero(command->command_buffer, IPS_COMMAND_LEN);
 229         command->arg = waiter->data;
 230         callback = waiter->callback;
 231         free(waiter, M_IPSBUF);
 232         callback(command);
 233         return;
 234 }
 235
 236 /*
 237  * returns a free command struct if one is available.
 238  * It also blanks out anything that may be a wild pointer/value.
 239  * Also, command buffers are not freed.  They are
 240  * small so they are saved and kept dmamapped and loaded.
 241  */
 242 int
 243 ips_get_free_cmd(ips_softc_t *sc, int (*callback)(ips_command_t *), void *data,
 244     unsigned long flags)
 245 {
 246         ips_command_t *command;
 247
 248         crit_enter();
 249         if (sc->state & IPS_OFFLINE) {
 250                 crit_exit();
 251                 return EIO;
 252         }
 253         command = SLIST_FIRST(&sc->free_cmd_list);
 254         if (!command || (sc->state & IPS_TIMEOUT)) {
 255                 crit_exit();
 256                 if (flags & IPS_NOWAIT_FLAG)
 257                         return EAGAIN;
 258                 return ips_add_waiting_command(sc, callback, data);
 259         }
 260         SLIST_REMOVE_HEAD(&sc->free_cmd_list, next);
 261         sc->used_commands++;
 262         crit_exit();
 263         clear_ips_command(command);
 264         bzero(command->command_buffer, IPS_COMMAND_LEN);
 265         command->arg = data;
 266         return callback(command);
 267 }
 268
 269 /* adds a command back to the free command queue */
 270 void
 271 ips_insert_free_cmd(ips_softc_t *sc, ips_command_t *command)
 272 {
 273         crit_enter();
 274         SLIST_INSERT_HEAD(&sc->free_cmd_list, command, next);
 275         sc->used_commands--;
 276         crit_exit();
 277         if (!(sc->state & IPS_TIMEOUT))
 278                 ips_run_waiting_command(sc);
 279 }
 280 static const char *
 281 ips_diskdev_statename(u_int8_t state)
 282 {
 283         static char statebuf[20];
 284
 285         switch(state) {
 286         case IPS_LD_OFFLINE:
 287                 return("OFFLINE");
 288                 break;
 289         case IPS_LD_OKAY:
 290                 return("OK");
 291                 break;
 292         case IPS_LD_DEGRADED:
 293                 return("DEGRADED");
 294                 break;
 295         case IPS_LD_FREE:
 296                 return("FREE");
 297                 break;
 298         case IPS_LD_SYS:
 299                 return("SYS");
 300                 break;
 301         case IPS_LD_CRS:
 302                 return("CRS");
 303                 break;
 304         }
 305         sprintf(statebuf, "UNKNOWN(0x%02x)", state);
 306         return (statebuf);
 307 }
 308
 309 static int
 310 ips_diskdev_init(ips_softc_t *sc)
 311 {
 312         int i;
 313
 314         for (i = 0; i < IPS_MAX_NUM_DRIVES; i++) {
 315                 if (sc->drives[i].state == IPS_LD_FREE)
 316                         continue;
 317                 device_printf(sc->dev,
 318                     "Logical Drive %d: RAID%d sectors: %u, state %s\n", i,
 319                     sc->drives[i].raid_lvl, sc->drives[i].sector_count,
 320                     ips_diskdev_statename(sc->drives[i].state));
 321                 if (sc->drives[i].state == IPS_LD_OKAY ||
 322                     sc->drives[i].state == IPS_LD_DEGRADED) {
 323                         sc->diskdev[i] = device_add_child(sc->dev, NULL, -1);
 324                         device_set_ivars(sc->diskdev[i], (void *)(uintptr_t)i);
 325                 }
 326         }
 327         if (bus_generic_attach(sc->dev))
 328                 device_printf(sc->dev, "Attaching bus failed\n");
 329         return 0;
 330 }
 331
 332 static int
 333 ips_diskdev_free(ips_softc_t *sc)
 334 {
 335         int i;
 336         int error = 0;
 337
 338         for (i = 0; i < IPS_MAX_NUM_DRIVES; i++) {
 339                 if (sc->diskdev[i] != NULL) {
 340                         error = device_delete_child(sc->dev, sc->diskdev[i]);
 341                         if (error)
 342                                 return error;
 343                 }
 344         }
 345         bus_generic_detach(sc->dev);
 346         return 0;
 347 }
 348
 349 /*
 350  * ips_timeout is periodically called to make sure no commands sent
 351  * to the card have become stuck.  If it finds a stuck command, it
 352  * sets a flag so the driver won't start any more commands and then
 353  * is periodically called to see if all outstanding commands have
 354  * either finished or timed out.  Once timed out, an attempt to
 355  * reinitialize the card is made.  If that fails, the driver gives
 356  * up and declares the card dead.
 357  */
 358 static void
 359 ips_timeout(void *arg)
 360 {
 361         ips_command_t *command;
 362         ips_softc_t *sc = arg;
 363         int i, state = 0;
 364
 365         command = &sc->commandarray[0];
 366         crit_enter();
 367         for (i = 0; i < sc->max_cmds; i++) {
 368                 if (!command[i].timeout)
 369                         continue;
 370                 command[i].timeout--;
 371                 if (command[i].timeout == 0) {
 372                         if (!(sc->state & IPS_TIMEOUT)) {
 373                                 sc->state |= IPS_TIMEOUT;
 374                                 device_printf(sc->dev, "WARNING: command timeout. Adapter is in toaster mode, resetting to known state\n");
 375                         }
 376                         command[i].status.value = IPS_ERROR_STATUS;
 377                         command[i].callback(&command[i]);
 378                         /* hmm, this should be enough cleanup */
 379                 } else
 380                         state = 1;
 381         }
 382         if (!state && (sc->state & IPS_TIMEOUT)) {
 383                 if (sc->ips_adapter_reinit(sc, 1)) {
 384                         device_printf(sc->dev, "AIEE! adapter reset failed, "
 385                             "giving up and going home! Have a nice day.\n");
 386                         sc->state |= IPS_OFFLINE;
 387                         sc->state &= ~IPS_TIMEOUT;
 388                         /*
 389                          * Grr, I hate this solution. I run waiting commands
 390                          * one at a time and error them out just before they
 391                          * would go to the card. This sucks.
 392                          */
 393                 } else
 394                         sc->state &= ~IPS_TIMEOUT;
 395                 ips_run_waiting_command(sc);
 396         }
 397         if (sc->state != IPS_OFFLINE)
 398                 callout_reset(&sc->timer, 10 * hz, ips_timeout, sc);
 399         crit_exit();
 400 }
 401
 402 /* check card and initialize it */
 403 int
 404 ips_adapter_init(ips_softc_t *sc)
 405 {
 406         int i;
 407         dev_t dev;
 408
 409         DEVICE_PRINTF(1, sc->dev, "initializing\n");
 410         if (bus_dma_tag_create( /* parent    */ sc->adapter_dmatag,
 411                                 /* alignemnt */ 1,
 412                                 /* boundary  */ 0,
 413                                 /* lowaddr   */ BUS_SPACE_MAXADDR_32BIT,
 414                                 /* highaddr  */ BUS_SPACE_MAXADDR,
 415                                 /* filter    */ NULL,
 416                                 /* filterarg */ NULL,
 417                                 /* maxsize   */ IPS_COMMAND_LEN +
 418                                                     IPS_MAX_SG_LEN,
 419                                 /* numsegs   */ 1,
 420                                 /* maxsegsize*/ IPS_COMMAND_LEN +
 421                                                     IPS_MAX_SG_LEN,
 422                                 /* flags     */ 0,
 423                                 &sc->command_dmatag) != 0) {
 424                 device_printf(sc->dev, "can't alloc command dma tag\n");
 425                 goto error;
 426         }
 427         if (bus_dma_tag_create( /* parent    */ sc->adapter_dmatag,
 428                                 /* alignemnt */ 1,
 429                                 /* boundary  */ 0,
 430                                 /* lowaddr   */ BUS_SPACE_MAXADDR_32BIT,
 431                                 /* highaddr  */ BUS_SPACE_MAXADDR,
 432                                 /* filter    */ NULL,
 433                                 /* filterarg */ NULL,
 434                                 /* maxsize   */ IPS_MAX_IOBUF_SIZE,
 435                                 /* numsegs   */ IPS_MAX_SG_ELEMENTS,
 436                                 /* maxsegsize*/ IPS_MAX_IOBUF_SIZE,
 437                                 /* flags     */ 0,
 438                                 &sc->sg_dmatag) != 0) {
 439                 device_printf(sc->dev, "can't alloc SG dma tag\n");
 440                 goto error;
 441         }
 442         /*
 443          * create one command buffer until we know how many commands this card
 444          * can handle
 445          */
 446         sc->max_cmds = 1;
 447         ips_cmdqueue_init(sc);
 448         callout_init(&sc->timer);
 449         if (sc->ips_adapter_reinit(sc, 0))
 450                 goto error;
 451         /* initialize ffdc values */
 452         microtime(&sc->ffdc_resettime);
 453         sc->ffdc_resetcount = 1;
 454         if ((i = ips_ffdc_reset(sc)) != 0) {
 455                 device_printf(sc->dev,
 456                     "failed to send ffdc reset to device (%d)\n", i);
 457                 goto error;
 458         }
 459         if ((i = ips_get_adapter_info(sc)) != 0) {
 460                 device_printf(sc->dev, "failed to get adapter configuration "
 461                     "data from device (%d)\n", i);
 462                 goto error;
 463         }
 464         /* no error check as failure doesn't matter */
 465         ips_update_nvram(sc);
 466         if (sc->adapter_type > 0 && sc->adapter_type <= IPS_ADAPTER_MAX_T) {
 467                 device_printf(sc->dev, "adapter type: %s\n",
 468                     ips_adapter_name[sc->adapter_type]);
 469         }
 470         if ((i = ips_get_drive_info(sc)) != 0) {
 471                 device_printf(sc->dev, "failed to get drive "
 472                     "configuration data from device (%d)\n", i);
 473                 goto error;
 474         }
 475         ips_cmdqueue_free(sc);
 476         if (sc->adapter_info.max_concurrent_cmds)
 477                 sc->max_cmds = min(128, sc->adapter_info.max_concurrent_cmds);
 478         else
 479                 sc->max_cmds = 32;
 480         if (ips_cmdqueue_init(sc)) {
 481                 device_printf(sc->dev,
 482                     "failed to initialize command buffers\n");
 483                 goto error;
 484         }
 485         cdevsw_add(&ips_cdevsw, -1, device_get_unit(sc->dev));
 486         dev = make_dev(&ips_cdevsw, device_get_unit(sc->dev),
 487                                    UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
 488                                    "ips%d", device_get_unit(sc->dev));
 489         dev->si_drv1 = sc;
 490         ips_diskdev_init(sc);
 491         callout_reset(&sc->timer, 10 * hz, ips_timeout, sc);
 492         return 0;
 493 error:
 494         ips_adapter_free(sc);
 495         return ENXIO;
 496 }
 497
 498 /*
 499  * see if we should reinitialize the card and wait for it to timeout
 500  * or complete initialization
 501  */
 502 int
 503 ips_morpheus_reinit(ips_softc_t *sc, int force)
 504 {
 505         u_int32_t tmp;
 506         int i;
 507
 508         tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
 509         if (!force && (ips_read_4(sc, MORPHEUS_REG_OMR0) >= IPS_POST1_OK) &&
 510             (ips_read_4(sc, MORPHEUS_REG_OMR1) != 0xdeadbeef) && !tmp) {
 511                 ips_write_4(sc, MORPHEUS_REG_OIMR, 0);
 512                 return 0;
 513         }
 514         ips_write_4(sc, MORPHEUS_REG_OIMR, 0xff);
 515         ips_read_4(sc, MORPHEUS_REG_OIMR);
 516         device_printf(sc->dev,
 517             "resetting adapter, this may take up to 5 minutes\n");
 518         ips_write_4(sc, MORPHEUS_REG_IDR, 0x80000000);
 519         DELAY(5000000);
 520         pci_read_config(sc->dev, 0, 4);
 521         tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
 522         for (i = 0; i < 45 && !(tmp & MORPHEUS_BIT_POST1); i++) {
 523                 DELAY(1000000);
 524                 DEVICE_PRINTF(2, sc->dev, "post1: %d\n", i);
 525                 tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
 526         }
 527         if (tmp & MORPHEUS_BIT_POST1)
 528                 ips_write_4(sc, MORPHEUS_REG_OISR, MORPHEUS_BIT_POST1);
 529
 530         if (i == 45 || ips_read_4(sc, MORPHEUS_REG_OMR0) < IPS_POST1_OK) {
 531                 device_printf(sc->dev,
 532                     "Adapter error during initialization.\n");
 533                 return 1;
 534         }
 535         for (i = 0; i < 240 && !(tmp & MORPHEUS_BIT_POST2); i++) {
 536                 DELAY(1000000);
 537                 DEVICE_PRINTF(2, sc->dev, "post2: %d\n", i);
 538                 tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
 539         }
 540         if (tmp & MORPHEUS_BIT_POST2)
 541                 ips_write_4(sc, MORPHEUS_REG_OISR, MORPHEUS_BIT_POST2);
 542
 543         if (i == 240 || !ips_read_4(sc, MORPHEUS_REG_OMR1)) {
 544                 device_printf(sc->dev, "adapter failed config check\n");
 545                 return 1;
 546         }
 547         ips_write_4(sc, MORPHEUS_REG_OIMR, 0);
 548         if (force && ips_clear_adapter(sc)) {
 549                 device_printf(sc->dev, "adapter clear failed\n");
 550                 return 1;
 551         }
 552         return 0;
 553 }
 554
 555 /* clean up so we can unload the driver. */
 556 int
 557 ips_adapter_free(ips_softc_t *sc)
 558 {
 559         int error = 0;
 560
 561         if (sc->state & IPS_DEV_OPEN)
 562                 return EBUSY;
 563         if ((error = ips_diskdev_free(sc)))
 564                 return error;
 565         if (ips_cmdqueue_free(sc)) {
 566                 device_printf(sc->dev,
 567                     "trying to exit when command queue is not empty!\n");
 568                 return EBUSY;
 569         }
 570         DEVICE_PRINTF(1, sc->dev, "free\n");
 571         crit_enter();
 572         callout_stop(&sc->timer);
 573         crit_exit();
 574         if (sc->sg_dmatag)
 575                 bus_dma_tag_destroy(sc->sg_dmatag);
 576         if (sc->command_dmatag)
 577                 bus_dma_tag_destroy(sc->command_dmatag);
 578         cdevsw_remove(&ips_cdevsw, -1, device_get_unit(sc->dev));
 579         return 0;
 580 }
 581
 582 void
 583 ips_morpheus_intr(void *void_sc)
 584 {
 585         ips_softc_t *sc = (ips_softc_t *)void_sc;
 586         u_int32_t oisr, iisr;
 587         ips_cmd_status_t status;
 588         ips_command_t *command;
 589         int cmdnumber;
 590
 591         iisr =ips_read_4(sc, MORPHEUS_REG_IISR);
 592         oisr =ips_read_4(sc, MORPHEUS_REG_OISR);
 593         PRINTF(9, "interrupt registers in:%x out:%x\n", iisr, oisr);
 594         if (!(oisr & MORPHEUS_BIT_CMD_IRQ)) {
 595                 DEVICE_PRINTF(2, sc->dev, "got a non-command irq\n");
 596                 return;
 597         }
 598         while ((status.value = ips_read_4(sc, MORPHEUS_REG_OQPR))
 599                != 0xffffffff) {
 600                 cmdnumber = status.fields.command_id;
 601                 command = &sc->commandarray[cmdnumber];
 602                 command->status.value = status.value;
 603                 command->timeout = 0;
 604                 command->callback(command);
 605                 DEVICE_PRINTF(9, sc->dev, "got command %d\n", cmdnumber);
 606         }
 607         return;
 608 }
 609
 610 void
 611 ips_issue_morpheus_cmd(ips_command_t *command)
 612 {
 613         crit_enter();
 614         /* hmmm, is there a cleaner way to do this? */
 615         if (command->sc->state & IPS_OFFLINE) {
 616                 crit_exit();
 617                 command->status.value = IPS_ERROR_STATUS;
 618                 command->callback(command);
 619                 return;
 620         }
 621         command->timeout = 10;
 622         ips_write_4(command->sc, MORPHEUS_REG_IQPR, command->command_phys_addr);
 623         crit_exit();
 624 }
 625
 626 static void
 627 ips_copperhead_queue_callback(void *queueptr, bus_dma_segment_t *segments,
 628                               int segnum, int error)
 629 {
 630         ips_copper_queue_t *queue = queueptr;
 631
 632         if (error)
 633                 return;
 634         queue->base_phys_addr = segments[0].ds_addr;
 635 }
 636
 637 static int
 638 ips_copperhead_queue_init(ips_softc_t *sc)
 639 {
 640         bus_dma_tag_t dmatag;
 641         bus_dmamap_t dmamap;
 642         int error;
 643
 644         if (bus_dma_tag_create( /* parent    */ sc->adapter_dmatag,
 645                                 /* alignemnt */ 1,
 646                                 /* boundary  */ 0,
 647                                 /* lowaddr   */ BUS_SPACE_MAXADDR_32BIT,
 648                                 /* highaddr  */ BUS_SPACE_MAXADDR,
 649                                 /* filter    */ NULL,
 650                                 /* filterarg */ NULL,
 651                                 /* maxsize   */ sizeof(ips_copper_queue_t),
 652                                 /* numsegs   */ 1,
 653                                 /* maxsegsize*/ sizeof(ips_copper_queue_t),
 654                                 /* flags     */ 0,
 655                                 &dmatag) != 0) {
 656                 device_printf(sc->dev, "can't alloc dma tag for statue queue\n");
 657                 error = ENOMEM;
 658                 goto exit;
 659         }
 660         if (bus_dmamem_alloc(dmatag, (void *)&(sc->copper_queue),
 661             BUS_DMA_NOWAIT, &dmamap)) {
 662                 error = ENOMEM;
 663                 goto exit;
 664         }
 665         bzero(sc->copper_queue, sizeof(ips_copper_queue_t));
 666         sc->copper_queue->dmatag = dmatag;
 667         sc->copper_queue->dmamap = dmamap;
 668         sc->copper_queue->nextstatus = 1;
 669         bus_dmamap_load(dmatag, dmamap, &(sc->copper_queue->status[0]),
 670             IPS_MAX_CMD_NUM * 4, ips_copperhead_queue_callback,
 671             sc->copper_queue, BUS_DMA_NOWAIT);
 672         if (sc->copper_queue->base_phys_addr == 0) {
 673                 error = ENOMEM;
 674                 goto exit;
 675         }
 676         ips_write_4(sc, COPPER_REG_SQSR, sc->copper_queue->base_phys_addr);
 677         ips_write_4(sc, COPPER_REG_SQER, sc->copper_queue->base_phys_addr +
 678             IPS_MAX_CMD_NUM * 4);
 679         ips_write_4(sc, COPPER_REG_SQHR, sc->copper_queue->base_phys_addr + 4);
 680         ips_write_4(sc, COPPER_REG_SQTR, sc->copper_queue->base_phys_addr);
 681         return 0;
 682 exit:
 683         bus_dmamem_free(dmatag, sc->copper_queue, dmamap);
 684         bus_dma_tag_destroy(dmatag);
 685         return error;
 686 }
 687
 688 /*
 689  * see if we should reinitialize the card and wait for it to timeout or
 690  * complete initialization FIXME
 691  */
 692 int
 693 ips_copperhead_reinit(ips_softc_t *sc, int force)
 694 {
 695         u_int32_t postcode = 0, configstatus = 0;
 696         int       i, j;
 697
 698         ips_write_1(sc, COPPER_REG_SCPR, 0x80);
 699         ips_write_1(sc, COPPER_REG_SCPR, 0);
 700         device_printf(sc->dev,
 701             "reinitializing adapter, this could take several minutes.\n");
 702         for (j = 0; j < 2; j++) {
 703                 postcode <<= 8;
 704                 for (i = 0; i < 45; i++) {
 705                         if (ips_read_1(sc, COPPER_REG_HISR) & COPPER_GHI_BIT) {
 706                                 postcode |= ips_read_1(sc, COPPER_REG_ISPR);
 707                                 ips_write_1(sc, COPPER_REG_HISR,
 708                                     COPPER_GHI_BIT);
 709                                 break;
 710                         } else
 711                                 DELAY(1000000);
 712                 }
 713                 if (i == 45)
 714                         return 1;
 715         }
 716         for (j = 0; j < 2; j++) {
 717                 configstatus <<= 8;
 718                 for (i = 0; i < 240; i++) {
 719                         if (ips_read_1(sc, COPPER_REG_HISR) & COPPER_GHI_BIT) {
 720                                 configstatus |= ips_read_1(sc, COPPER_REG_ISPR);
 721                                 ips_write_1(sc, COPPER_REG_HISR,
 722                                     COPPER_GHI_BIT);
 723                                 break;
 724                         } else
 725                                 DELAY(1000000);
 726                 }
 727                 if (i == 240)
 728                         return 1;
 729         }
 730         for (i = 0; i < 240; i++) {
 731                 if (!(ips_read_1(sc, COPPER_REG_CBSP) & COPPER_OP_BIT))
 732                         break;
 733                 else
 734                         DELAY(1000000);
 735         }
 736         if (i == 240)
 737                 return 1;
 738         ips_write_2(sc, COPPER_REG_CCCR, 0x1000 | COPPER_ILE_BIT);
 739         ips_write_1(sc, COPPER_REG_SCPR, COPPER_EBM_BIT);
 740         ips_copperhead_queue_init(sc);
 741         ips_write_1(sc, COPPER_REG_HISR, COPPER_GHI_BIT);
 742         i = ips_read_1(sc, COPPER_REG_SCPR);
 743         ips_write_1(sc, COPPER_REG_HISR, COPPER_EI_BIT);
 744         if (configstatus == 0) {
 745                 device_printf(sc->dev, "adapter initialization failed\n");
 746                 return 1;
 747         }
 748         if (force && ips_clear_adapter(sc)) {
 749                 device_printf(sc->dev, "adapter clear failed\n");
 750                 return 1;
 751         }
 752         return 0;
 753 }
 754
 755 static u_int32_t
 756 ips_copperhead_cmd_status(ips_softc_t *sc)
 757 {
 758         u_int32_t value;
 759         int statnum;
 760
 761         statnum = sc->copper_queue->nextstatus++;
 762         if (sc->copper_queue->nextstatus == IPS_MAX_CMD_NUM)
 763                 sc->copper_queue->nextstatus = 0;
 764         crit_enter();
 765         value = sc->copper_queue->status[statnum];
 766         ips_write_4(sc, COPPER_REG_SQTR, sc->copper_queue->base_phys_addr +
 767             4 * statnum);
 768         crit_exit();
 769         return value;
 770 }
 771
 772 void
 773 ips_copperhead_intr(void *void_sc)
 774 {
 775         ips_softc_t *sc = (ips_softc_t *)void_sc;
 776         ips_cmd_status_t status;
 777         int cmdnumber;
 778
 779         while (ips_read_1(sc, COPPER_REG_HISR) & COPPER_SCE_BIT) {
 780                 status.value = ips_copperhead_cmd_status(sc);
 781                 cmdnumber = status.fields.command_id;
 782                 sc->commandarray[cmdnumber].status.value = status.value;
 783                 sc->commandarray[cmdnumber].timeout = 0;
 784                 sc->commandarray[cmdnumber].callback(&(sc->commandarray[cmdnumber]));
 785                 PRINTF(9, "ips: got command %d\n", cmdnumber);
 786         }
 787         return;
 788 }
 789
 790 void
 791 ips_issue_copperhead_cmd(ips_command_t *command)
 792 {
 793         int i;
 794
 795         crit_enter();
 796         /* hmmm, is there a cleaner way to do this? */
 797         if (command->sc->state & IPS_OFFLINE) {
 798                 crit_exit();
 799                 command->status.value = IPS_ERROR_STATUS;
 800                 command->callback(command);
 801                 return;
 802         }
 803         command->timeout = 10;
 804         for (i = 0; ips_read_4(command->sc, COPPER_REG_CCCR) & COPPER_SEM_BIT;
 805             i++) {
 806                 if (i == 20) {
 807                         printf("sem bit still set, can't send a command\n");
 808                         crit_exit();
 809                         return;
 810                 }
 811                 DELAY(500);     /* need to do a delay here */
 812         }
 813         ips_write_4(command->sc, COPPER_REG_CCSAR, command->command_phys_addr);
 814         ips_write_2(command->sc, COPPER_REG_CCCR, COPPER_CMD_START);
 815         crit_exit();
 816 }