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