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