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.10 2004/12/10 04:09:46 y0netan1 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 /* initialize ffdc values */ 458 microtime(&sc->ffdc_resettime); 459 sc->ffdc_resetcount = 1; 460 if ((i = ips_ffdc_reset(sc)) != 0) { 461 device_printf(sc->dev, 462 "failed to send ffdc reset to device (%d)\n", i); 463 goto error; 464 } 465 if ((i = ips_get_adapter_info(sc)) != 0) { 466 device_printf(sc->dev, "failed to get adapter configuration " 467 "data from device (%d)\n", i); 468 goto error; 469 } 470 /* no error check as failure doesn't matter */ 471 ips_update_nvram(sc); 472 if (sc->adapter_type > 0 && sc->adapter_type <= IPS_ADAPTER_MAX_T) { 473 device_printf(sc->dev, "adapter type: %s\n", 474 ips_adapter_name[sc->adapter_type]); 475 } 476 if ((i = ips_get_drive_info(sc)) != 0) { 477 device_printf(sc->dev, "failed to get drive " 478 "configuration data from device (%d)\n", i); 479 goto error; 480 } 481 ips_cmdqueue_free(sc); 482 if (sc->adapter_info.max_concurrent_cmds) 483 sc->max_cmds = min(128, sc->adapter_info.max_concurrent_cmds); 484 else 485 sc->max_cmds = 32; 486 if (ips_cmdqueue_init(sc)) { 487 device_printf(sc->dev, 488 "failed to initialize command buffers\n"); 489 goto error; 490 } 491 cdevsw_add(&ips_cdevsw, -1, device_get_unit(sc->dev)); 492 dev = make_dev(&ips_cdevsw, device_get_unit(sc->dev), 493 UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR, 494 "ips%d", device_get_unit(sc->dev)); 495 dev->si_drv1 = sc; 496 ips_diskdev_init(sc); 497 callout_reset(&sc->timer, 10 * hz, ips_timeout, sc); 498 return 0; 499 error: 500 ips_adapter_free(sc); 501 return ENXIO; 502 } 503 504 /* 505 * see if we should reinitialize the card and wait for it to timeout 506 * or complete initialization 507 */ 508 int 509 ips_morpheus_reinit(ips_softc_t *sc, int force) 510 { 511 u_int32_t tmp; 512 int i; 513 514 tmp = ips_read_4(sc, MORPHEUS_REG_OISR); 515 if (!force && (ips_read_4(sc, MORPHEUS_REG_OMR0) >= IPS_POST1_OK) && 516 (ips_read_4(sc, MORPHEUS_REG_OMR1) != 0xdeadbeef) && !tmp) { 517 ips_write_4(sc, MORPHEUS_REG_OIMR, 0); 518 return 0; 519 } 520 ips_write_4(sc, MORPHEUS_REG_OIMR, 0xff); 521 ips_read_4(sc, MORPHEUS_REG_OIMR); 522 device_printf(sc->dev, 523 "resetting adapter, this may take up to 5 minutes\n"); 524 ips_write_4(sc, MORPHEUS_REG_IDR, 0x80000000); 525 DELAY(5000000); 526 pci_read_config(sc->dev, 0, 4); 527 tmp = ips_read_4(sc, MORPHEUS_REG_OISR); 528 for (i = 0; i < 45 && !(tmp & MORPHEUS_BIT_POST1); i++) { 529 DELAY(1000000); 530 DEVICE_PRINTF(2, sc->dev, "post1: %d\n", i); 531 tmp = ips_read_4(sc, MORPHEUS_REG_OISR); 532 } 533 if (tmp & MORPHEUS_BIT_POST1) 534 ips_write_4(sc, MORPHEUS_REG_OISR, MORPHEUS_BIT_POST1); 535 536 if (i == 45 || ips_read_4(sc, MORPHEUS_REG_OMR0) < IPS_POST1_OK) { 537 device_printf(sc->dev, 538 "Adapter error during initialization.\n"); 539 return 1; 540 } 541 for (i = 0; i < 240 && !(tmp & MORPHEUS_BIT_POST2); i++) { 542 DELAY(1000000); 543 DEVICE_PRINTF(2, sc->dev, "post2: %d\n", i); 544 tmp = ips_read_4(sc, MORPHEUS_REG_OISR); 545 } 546 if (tmp & MORPHEUS_BIT_POST2) 547 ips_write_4(sc, MORPHEUS_REG_OISR, MORPHEUS_BIT_POST2); 548 549 if (i == 240 || !ips_read_4(sc, MORPHEUS_REG_OMR1)) { 550 device_printf(sc->dev, "adapter failed config check\n"); 551 return 1; 552 } 553 ips_write_4(sc, MORPHEUS_REG_OIMR, 0); 554 if (force && ips_clear_adapter(sc)) { 555 device_printf(sc->dev, "adapter clear failed\n"); 556 return 1; 557 } 558 return 0; 559 } 560 561 /* clean up so we can unload the driver. */ 562 int 563 ips_adapter_free(ips_softc_t *sc) 564 { 565 int error = 0; 566 intrmask_t mask; 567 if (sc->state & IPS_DEV_OPEN) 568 return EBUSY; 569 if ((error = ips_diskdev_free(sc))) 570 return error; 571 if (ips_cmdqueue_free(sc)) { 572 device_printf(sc->dev, 573 "trying to exit when command queue is not empty!\n"); 574 return EBUSY; 575 } 576 DEVICE_PRINTF(1, sc->dev, "free\n"); 577 mask = splbio(); 578 callout_stop(&sc->timer); 579 splx(mask); 580 if (sc->sg_dmatag) 581 bus_dma_tag_destroy(sc->sg_dmatag); 582 if (sc->command_dmatag) 583 bus_dma_tag_destroy(sc->command_dmatag); 584 cdevsw_remove(&ips_cdevsw, -1, device_get_unit(sc->dev)); 585 return 0; 586 } 587 588 void 589 ips_morpheus_intr(void *void_sc) 590 { 591 ips_softc_t *sc = (ips_softc_t *)void_sc; 592 u_int32_t oisr, iisr; 593 ips_cmd_status_t status; 594 ips_command_t *command; 595 int cmdnumber; 596 597 iisr =ips_read_4(sc, MORPHEUS_REG_IISR); 598 oisr =ips_read_4(sc, MORPHEUS_REG_OISR); 599 PRINTF(9, "interrupt registers in:%x out:%x\n", iisr, oisr); 600 if (!(oisr & MORPHEUS_BIT_CMD_IRQ)) { 601 DEVICE_PRINTF(2, sc->dev, "got a non-command irq\n"); 602 return; 603 } 604 while ((status.value = ips_read_4(sc, MORPHEUS_REG_OQPR)) 605 != 0xffffffff) { 606 cmdnumber = status.fields.command_id; 607 command = &sc->commandarray[cmdnumber]; 608 command->status.value = status.value; 609 command->timeout = 0; 610 command->callback(command); 611 DEVICE_PRINTF(9, sc->dev, "got command %d\n", cmdnumber); 612 } 613 return; 614 } 615 616 void 617 ips_issue_morpheus_cmd(ips_command_t *command) 618 { 619 intrmask_t mask; 620 621 mask = splbio(); 622 /* hmmm, is there a cleaner way to do this? */ 623 if (command->sc->state & IPS_OFFLINE) { 624 splx(mask); 625 command->status.value = IPS_ERROR_STATUS; 626 command->callback(command); 627 return; 628 } 629 command->timeout = 10; 630 ips_write_4(command->sc, MORPHEUS_REG_IQPR, command->command_phys_addr); 631 splx(mask); 632 } 633 634 static void 635 ips_copperhead_queue_callback(void *queueptr, bus_dma_segment_t *segments, 636 int segnum, int error) 637 { 638 ips_copper_queue_t *queue = queueptr; 639 640 if (error) 641 return; 642 queue->base_phys_addr = segments[0].ds_addr; 643 } 644 645 static int 646 ips_copperhead_queue_init(ips_softc_t *sc) 647 { 648 bus_dma_tag_t dmatag; 649 bus_dmamap_t dmamap; 650 int error; 651 652 if (bus_dma_tag_create( /* parent */ sc->adapter_dmatag, 653 /* alignemnt */ 1, 654 /* boundary */ 0, 655 /* lowaddr */ BUS_SPACE_MAXADDR_32BIT, 656 /* highaddr */ BUS_SPACE_MAXADDR, 657 /* filter */ NULL, 658 /* filterarg */ NULL, 659 /* maxsize */ sizeof(ips_copper_queue_t), 660 /* numsegs */ 1, 661 /* maxsegsize*/ sizeof(ips_copper_queue_t), 662 /* flags */ 0, 663 &dmatag) != 0) { 664 device_printf(sc->dev, "can't alloc dma tag for statue queue\n"); 665 error = ENOMEM; 666 goto exit; 667 } 668 if (bus_dmamem_alloc(dmatag, (void *)&(sc->copper_queue), 669 BUS_DMA_NOWAIT, &dmamap)) { 670 error = ENOMEM; 671 goto exit; 672 } 673 bzero(sc->copper_queue, sizeof(ips_copper_queue_t)); 674 sc->copper_queue->dmatag = dmatag; 675 sc->copper_queue->dmamap = dmamap; 676 sc->copper_queue->nextstatus = 1; 677 bus_dmamap_load(dmatag, dmamap, &(sc->copper_queue->status[0]), 678 IPS_MAX_CMD_NUM * 4, ips_copperhead_queue_callback, 679 sc->copper_queue, BUS_DMA_NOWAIT); 680 if (sc->copper_queue->base_phys_addr == 0) { 681 error = ENOMEM; 682 goto exit; 683 } 684 ips_write_4(sc, COPPER_REG_SQSR, sc->copper_queue->base_phys_addr); 685 ips_write_4(sc, COPPER_REG_SQER, sc->copper_queue->base_phys_addr + 686 IPS_MAX_CMD_NUM * 4); 687 ips_write_4(sc, COPPER_REG_SQHR, sc->copper_queue->base_phys_addr + 4); 688 ips_write_4(sc, COPPER_REG_SQTR, sc->copper_queue->base_phys_addr); 689 return 0; 690 exit: 691 bus_dmamem_free(dmatag, sc->copper_queue, dmamap); 692 bus_dma_tag_destroy(dmatag); 693 return error; 694 } 695 696 /* 697 * see if we should reinitialize the card and wait for it to timeout or 698 * complete initialization FIXME 699 */ 700 int 701 ips_copperhead_reinit(ips_softc_t *sc, int force) 702 { 703 u_int32_t postcode = 0, configstatus = 0; 704 int i, j; 705 706 ips_write_1(sc, COPPER_REG_SCPR, 0x80); 707 ips_write_1(sc, COPPER_REG_SCPR, 0); 708 device_printf(sc->dev, 709 "reinitializing adapter, this could take several minutes.\n"); 710 for (j = 0; j < 2; j++) { 711 postcode <<= 8; 712 for (i = 0; i < 45; i++) { 713 if (ips_read_1(sc, COPPER_REG_HISR) & COPPER_GHI_BIT) { 714 postcode |= ips_read_1(sc, COPPER_REG_ISPR); 715 ips_write_1(sc, COPPER_REG_HISR, 716 COPPER_GHI_BIT); 717 break; 718 } else 719 DELAY(1000000); 720 } 721 if (i == 45) 722 return 1; 723 } 724 for (j = 0; j < 2; j++) { 725 configstatus <<= 8; 726 for (i = 0; i < 240; i++) { 727 if (ips_read_1(sc, COPPER_REG_HISR) & COPPER_GHI_BIT) { 728 configstatus |= ips_read_1(sc, COPPER_REG_ISPR); 729 ips_write_1(sc, COPPER_REG_HISR, 730 COPPER_GHI_BIT); 731 break; 732 } else 733 DELAY(1000000); 734 } 735 if (i == 240) 736 return 1; 737 } 738 for (i = 0; i < 240; i++) { 739 if (!(ips_read_1(sc, COPPER_REG_CBSP) & COPPER_OP_BIT)) 740 break; 741 else 742 DELAY(1000000); 743 } 744 if (i == 240) 745 return 1; 746 ips_write_2(sc, COPPER_REG_CCCR, 0x1000 | COPPER_ILE_BIT); 747 ips_write_1(sc, COPPER_REG_SCPR, COPPER_EBM_BIT); 748 ips_copperhead_queue_init(sc); 749 ips_write_1(sc, COPPER_REG_HISR, COPPER_GHI_BIT); 750 i = ips_read_1(sc, COPPER_REG_SCPR); 751 ips_write_1(sc, COPPER_REG_HISR, COPPER_EI_BIT); 752 if (configstatus == 0) { 753 device_printf(sc->dev, "adapter initialization failed\n"); 754 return 1; 755 } 756 if (force && ips_clear_adapter(sc)) { 757 device_printf(sc->dev, "adapter clear failed\n"); 758 return 1; 759 } 760 return 0; 761 } 762 763 static u_int32_t 764 ips_copperhead_cmd_status(ips_softc_t *sc) 765 { 766 intrmask_t mask; 767 u_int32_t value; 768 int statnum; 769 770 statnum = sc->copper_queue->nextstatus++; 771 if (sc->copper_queue->nextstatus == IPS_MAX_CMD_NUM) 772 sc->copper_queue->nextstatus = 0; 773 mask = splbio(); 774 value = sc->copper_queue->status[statnum]; 775 ips_write_4(sc, COPPER_REG_SQTR, sc->copper_queue->base_phys_addr + 776 4 * statnum); 777 splx(mask); 778 return value; 779 } 780 781 void 782 ips_copperhead_intr(void *void_sc) 783 { 784 ips_softc_t *sc = (ips_softc_t *)void_sc; 785 ips_cmd_status_t status; 786 int cmdnumber; 787 788 while (ips_read_1(sc, COPPER_REG_HISR) & COPPER_SCE_BIT) { 789 status.value = ips_copperhead_cmd_status(sc); 790 cmdnumber = status.fields.command_id; 791 sc->commandarray[cmdnumber].status.value = status.value; 792 sc->commandarray[cmdnumber].timeout = 0; 793 sc->commandarray[cmdnumber].callback(&(sc->commandarray[cmdnumber])); 794 PRINTF(9, "ips: got command %d\n", cmdnumber); 795 } 796 return; 797 } 798 799 void 800 ips_issue_copperhead_cmd(ips_command_t *command) 801 { 802 intrmask_t mask; 803 int i; 804 805 mask = splbio(); 806 /* hmmm, is there a cleaner way to do this? */ 807 if (command->sc->state & IPS_OFFLINE) { 808 splx(mask); 809 command->status.value = IPS_ERROR_STATUS; 810 command->callback(command); 811 return; 812 } 813 command->timeout = 10; 814 for (i = 0; ips_read_4(command->sc, COPPER_REG_CCCR) & COPPER_SEM_BIT; 815 i++) { 816 if (i == 20) { 817 printf("sem bit still set, can't send a command\n"); 818 splx(mask); 819 return; 820 } 821 DELAY(500); /* need to do a delay here */ 822 } 823 ips_write_4(command->sc, COPPER_REG_CCSAR, command->command_phys_addr); 824 ips_write_2(command->sc, COPPER_REG_CCCR, COPPER_CMD_START); 825 splx(mask); 826 } 827