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