Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/twa/twa_freebsd.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2003-04 3ware, Inc. 3 * Copyright (c) 2000 Michael Smith 4 * Copyright (c) 2000 BSDi 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD: releng/5.4/sys/dev/twa/twa_freebsd.c 144041 2005-03-23 22:57:47Z vkashyap $ 29 */ 30 31 /* 32 * 3ware driver for 9000 series storage controllers. 33 * 34 * Author: Vinod Kashyap 35 */ 36 37 38 #include <dev/twa/twa_includes.h> 39 40 static void twa_setup_data_dmamap(void *arg, bus_dma_segment_t *segs, 41 int nsegments, int error); 42 static void twa_setup_request_dmamap(void *arg, bus_dma_segment_t *segs, 43 int nsegments, int error); 44 45 MALLOC_DEFINE(TWA_MALLOC_CLASS, "twa commands", "twa commands"); 46 47 48 static d_open_t twa_open; 49 static d_close_t twa_close; 50 static d_ioctl_t twa_ioctl_wrapper; 51 52 static struct cdevsw twa_cdevsw = { 53 .d_version = D_VERSION, 54 .d_flags = D_NEEDGIANT, 55 .d_open = twa_open, 56 .d_close = twa_close, 57 .d_ioctl = twa_ioctl_wrapper, 58 .d_name = "twa", 59 }; 60 61 static devclass_t twa_devclass; 62 63 64 /* 65 * Function name: twa_open 66 * Description: Called when the controller is opened. 67 * Simply marks the controller as open. 68 * 69 * Input: dev -- control device corresponding to the ctlr 70 * flags -- mode of open 71 * fmt -- device type (character/block etc.) 72 * proc -- current process 73 * Output: None 74 * Return value: 0 -- success 75 * non-zero-- failure 76 */ 77 static int 78 twa_open(struct cdev *dev, int flags, int fmt, d_thread_t *proc) 79 { 80 int unit = minor(dev); 81 struct twa_softc *sc = devclass_get_softc(twa_devclass, unit); 82 83 sc->twa_state |= TWA_STATE_OPEN; 84 return(0); 85 } 86 87 88 89 /* 90 * Function name: twa_close 91 * Description: Called when the controller is closed. 92 * Simply marks the controller as not open. 93 * 94 * Input: dev -- control device corresponding to the ctlr 95 * flags -- mode of corresponding open 96 * fmt -- device type (character/block etc.) 97 * proc -- current process 98 * Output: None 99 * Return value: 0 -- success 100 * non-zero-- failure 101 */ 102 static int 103 twa_close(struct cdev *dev, int flags, int fmt, d_thread_t *proc) 104 { 105 int unit = minor(dev); 106 struct twa_softc *sc = devclass_get_softc(twa_devclass, unit); 107 108 sc->twa_state &= ~TWA_STATE_OPEN; 109 return(0); 110 } 111 112 113 114 /* 115 * Function name: twa_ioctl_wrapper 116 * Description: Called when an ioctl is posted to the controller. 117 * Simply calls the ioctl handler. 118 * 119 * Input: dev -- control device corresponding to the ctlr 120 * cmd -- ioctl cmd 121 * buf -- ptr to buffer in kernel memory, which is 122 * a copy of the input buffer in user-space 123 * flags -- mode of corresponding open 124 * proc -- current process 125 * Output: buf -- ptr to buffer in kernel memory, which will 126 * be copied to the output buffer in user-space 127 * Return value: 0 -- success 128 * non-zero-- failure 129 */ 130 static int 131 twa_ioctl_wrapper(struct cdev *dev, u_long cmd, caddr_t buf, 132 int flags, d_thread_t *proc) 133 { 134 struct twa_softc *sc = (struct twa_softc *)(dev->si_drv1); 135 136 return(twa_ioctl(sc, cmd, buf)); 137 } 138 139 140 141 static int twa_probe (device_t dev); 142 static int twa_attach (device_t dev); 143 static void twa_free (struct twa_softc *sc); 144 static int twa_detach (device_t dev); 145 static int twa_shutdown (device_t dev); 146 static int twa_suspend (device_t dev); 147 static int twa_resume (device_t dev); 148 static void twa_pci_intr(void *arg); 149 150 static device_method_t twa_methods[] = { 151 /* Device interface */ 152 DEVMETHOD(device_probe, twa_probe), 153 DEVMETHOD(device_attach, twa_attach), 154 DEVMETHOD(device_detach, twa_detach), 155 DEVMETHOD(device_shutdown, twa_shutdown), 156 DEVMETHOD(device_suspend, twa_suspend), 157 DEVMETHOD(device_resume, twa_resume), 158 159 DEVMETHOD(bus_print_child, bus_generic_print_child), 160 DEVMETHOD(bus_driver_added, bus_generic_driver_added), 161 {0, 0} 162 }; 163 164 static driver_t twa_pci_driver = { 165 "twa", 166 twa_methods, 167 sizeof(struct twa_softc) 168 }; 169 170 DRIVER_MODULE(twa, pci, twa_pci_driver, twa_devclass, 0, 0); 171 172 173 174 /* 175 * Function name: twa_probe 176 * Description: Called at driver load time. Claims 9000 ctlrs. 177 * 178 * Input: dev -- bus device corresponding to the ctlr 179 * Output: None 180 * Return value: <= 0 -- success 181 * > 0 -- failure 182 */ 183 static int 184 twa_probe(device_t dev) 185 { 186 static u_int8_t first_ctlr = 1; 187 188 twa_dbg_print(3, "entered"); 189 190 if ((pci_get_vendor(dev) == TWA_VENDOR_ID) && 191 (pci_get_device(dev) == TWA_DEVICE_ID_9K)) { 192 device_set_desc(dev, TWA_DEVICE_NAME); 193 /* Print the driver version only once. */ 194 if (first_ctlr) { 195 printf("3ware device driver for 9000 series storage controllers, version: %s\n", 196 TWA_DRIVER_VERSION_STRING); 197 first_ctlr = 0; 198 } 199 return(BUS_PROBE_DEFAULT); 200 } 201 return(ENXIO); 202 } 203 204 205 206 /* 207 * Function name: twa_attach 208 * Description: Allocates pci resources; updates sc; adds a node to the 209 * sysctl tree to expose the driver version; makes calls 210 * to initialize ctlr, and to attach to CAM. 211 * 212 * Input: dev -- bus device corresponding to the ctlr 213 * Output: None 214 * Return value: 0 -- success 215 * non-zero-- failure 216 */ 217 static int 218 twa_attach(device_t dev) 219 { 220 struct twa_softc *sc = device_get_softc(dev); 221 u_int32_t command; 222 int res_id; 223 int error; 224 225 twa_dbg_dprint_enter(3, sc); 226 227 /* Initialize the softc structure. */ 228 sc->twa_bus_dev = dev; 229 230 sysctl_ctx_init(&sc->twa_sysctl_ctx); 231 sc->twa_sysctl_tree = SYSCTL_ADD_NODE(&sc->twa_sysctl_ctx, 232 SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, 233 device_get_nameunit(dev), CTLFLAG_RD, 0, ""); 234 if (sc->twa_sysctl_tree == NULL) { 235 twa_printf(sc, "Cannot add sysctl tree node.\n"); 236 return(ENXIO); 237 } 238 SYSCTL_ADD_STRING(&sc->twa_sysctl_ctx, SYSCTL_CHILDREN(sc->twa_sysctl_tree), 239 OID_AUTO, "driver_version", CTLFLAG_RD, 240 TWA_DRIVER_VERSION_STRING, 0, "TWA driver version"); 241 242 /* Make sure we are going to be able to talk to this board. */ 243 command = pci_read_config(dev, PCIR_COMMAND, 2); 244 if ((command & PCIM_CMD_PORTEN) == 0) { 245 twa_printf(sc, "Register window not available.\n"); 246 return(ENXIO); 247 } 248 249 /* Force the busmaster enable bit on, in case the BIOS forgot. */ 250 command |= PCIM_CMD_BUSMASTEREN; 251 pci_write_config(dev, PCIR_COMMAND, command, 2); 252 253 /* Allocate the PCI register window. */ 254 res_id = TWA_IO_CONFIG_REG; 255 if ((sc->twa_io_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &res_id, 256 0, ~0, 1, RF_ACTIVE)) == NULL) { 257 twa_printf(sc, "can't allocate register window.\n"); 258 twa_free(sc); 259 return(ENXIO); 260 } 261 sc->twa_bus_tag = rman_get_bustag(sc->twa_io_res); 262 sc->twa_bus_handle = rman_get_bushandle(sc->twa_io_res); 263 264 /* Initialize the driver for this controller. */ 265 if ((error = twa_setup(sc))) { 266 twa_free(sc); 267 return(error); 268 } 269 270 /* Print some information about the controller and configuration. */ 271 twa_describe_controller(sc); 272 273 /* Allocate and connect our interrupt. */ 274 res_id = 0; 275 if ((sc->twa_irq_res = bus_alloc_resource(sc->twa_bus_dev, SYS_RES_IRQ, 276 &res_id, 0, ~0, 1, 277 RF_SHAREABLE | RF_ACTIVE)) == NULL) { 278 twa_printf(sc, "Can't allocate interrupt.\n"); 279 twa_free(sc); 280 return(ENXIO); 281 } 282 if (bus_setup_intr(sc->twa_bus_dev, sc->twa_irq_res, INTR_TYPE_CAM, 283 twa_pci_intr, sc, &sc->twa_intr_handle)) { 284 twa_printf(sc, "Can't set up interrupt.\n"); 285 twa_free(sc); 286 return(ENXIO); 287 } 288 289 /* Create the control device. */ 290 sc->twa_ctrl_dev = make_dev(&twa_cdevsw, device_get_unit(sc->twa_bus_dev), 291 UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR, 292 "twa%d", device_get_unit(sc->twa_bus_dev)); 293 sc->twa_ctrl_dev->si_drv1 = sc; 294 295 if ((error = twa_cam_setup(sc))) { 296 twa_free(sc); 297 return(error); 298 } 299 return(0); 300 } 301 302 303 304 /* 305 * Function name: twa_free 306 * Description: Performs clean-up at the time of going down. 307 * 308 * Input: sc -- ptr to per ctlr structure 309 * Output: None 310 * Return value: None 311 */ 312 static void 313 twa_free(struct twa_softc *sc) 314 { 315 struct twa_request *tr; 316 317 twa_dbg_dprint_enter(3, sc); 318 319 /* Detach from CAM */ 320 twa_cam_detach(sc); 321 322 /* Destroy dma handles. */ 323 324 bus_dmamap_unload(sc->twa_cmd_tag, sc->twa_cmd_map); 325 while ((tr = twa_dequeue_free(sc)) != NULL) 326 bus_dmamap_destroy(sc->twa_buf_tag, tr->tr_buf_map); 327 328 /* Free all memory allocated so far. */ 329 if (sc->twa_req_buf) 330 free(sc->twa_req_buf, TWA_MALLOC_CLASS); 331 if (sc->twa_cmd_pkt_buf) 332 bus_dmamem_free(sc->twa_cmd_tag, sc->twa_cmd_pkt_buf, 333 sc->twa_cmd_map); 334 if (sc->twa_aen_queue[0]) 335 free(sc->twa_aen_queue[0], M_DEVBUF); 336 337 /* Destroy the data-transfer DMA tag. */ 338 if (sc->twa_buf_tag) 339 bus_dma_tag_destroy(sc->twa_buf_tag); 340 341 /* Destroy the cmd DMA tag. */ 342 if (sc->twa_cmd_tag) 343 bus_dma_tag_destroy(sc->twa_cmd_tag); 344 345 /* Destroy the parent DMA tag. */ 346 if (sc->twa_parent_tag) 347 bus_dma_tag_destroy(sc->twa_parent_tag); 348 349 /* Disconnect the interrupt handler. */ 350 if (sc->twa_intr_handle) 351 bus_teardown_intr(sc->twa_bus_dev, sc->twa_irq_res, 352 sc->twa_intr_handle); 353 if (sc->twa_irq_res != NULL) 354 bus_release_resource(sc->twa_bus_dev, SYS_RES_IRQ, 355 0, sc->twa_irq_res); 356 357 /* Release the register window mapping. */ 358 if (sc->twa_io_res != NULL) 359 bus_release_resource(sc->twa_bus_dev, SYS_RES_IOPORT, 360 TWA_IO_CONFIG_REG, sc->twa_io_res); 361 362 /* Destroy the control device. */ 363 if (sc->twa_ctrl_dev != (struct cdev *)NULL) 364 destroy_dev(sc->twa_ctrl_dev); 365 366 sysctl_ctx_free(&sc->twa_sysctl_ctx); 367 } 368 369 370 371 /* 372 * Function name: twa_detach 373 * Description: Called when the controller is being detached from 374 * the pci bus. 375 * 376 * Input: dev -- bus device corresponding to the ctlr 377 * Output: None 378 * Return value: 0 -- success 379 * non-zero-- failure 380 */ 381 static int 382 twa_detach(device_t dev) 383 { 384 struct twa_softc *sc = device_get_softc(dev); 385 int s; 386 int error; 387 388 twa_dbg_dprint_enter(3, sc); 389 390 error = EBUSY; 391 s = splcam(); 392 if (sc->twa_state & TWA_STATE_OPEN) 393 goto out; 394 395 /* Shut the controller down. */ 396 if ((error = twa_shutdown(dev))) 397 goto out; 398 399 /* Free all resources associated with this controller. */ 400 twa_free(sc); 401 error = 0; 402 403 out: 404 splx(s); 405 return(error); 406 } 407 408 409 410 /* 411 * Function name: twa_shutdown 412 * Description: Called at unload/shutdown time. Lets the controller 413 * know that we are going down. 414 * 415 * Input: dev -- bus device corresponding to the ctlr 416 * Output: None 417 * Return value: 0 -- success 418 * non-zero-- failure 419 */ 420 static int 421 twa_shutdown(device_t dev) 422 { 423 struct twa_softc *sc = device_get_softc(dev); 424 int s; 425 int error = 0; 426 427 twa_dbg_dprint_enter(3, sc); 428 429 s = splcam(); 430 431 /* Disconnect from the controller. */ 432 error = twa_deinit_ctlr(sc); 433 434 splx(s); 435 return(error); 436 } 437 438 439 440 /* 441 * Function name: twa_suspend 442 * Description: Called to suspend I/O before hot-swapping PCI ctlrs. 443 * Doesn't do much as of now. 444 * 445 * Input: dev -- bus device corresponding to the ctlr 446 * Output: None 447 * Return value: 0 -- success 448 * non-zero-- failure 449 */ 450 static int 451 twa_suspend(device_t dev) 452 { 453 struct twa_softc *sc = device_get_softc(dev); 454 int s; 455 456 twa_dbg_dprint_enter(3, sc); 457 458 s = splcam(); 459 sc->twa_state |= TWA_STATE_SUSPEND; 460 461 twa_disable_interrupts(sc); 462 splx(s); 463 464 return(1); 465 } 466 467 468 469 /* 470 * Function name: twa_resume 471 * Description: Called to resume I/O after hot-swapping PCI ctlrs. 472 * Doesn't do much as of now. 473 * 474 * Input: dev -- bus device corresponding to the ctlr 475 * Output: None 476 * Return value: 0 -- success 477 * non-zero-- failure 478 */ 479 static int 480 twa_resume(device_t dev) 481 { 482 struct twa_softc *sc = device_get_softc(dev); 483 484 twa_dbg_dprint_enter(3, sc); 485 486 sc->twa_state &= ~TWA_STATE_SUSPEND; 487 twa_enable_interrupts(sc); 488 489 return(1); 490 } 491 492 493 494 /* 495 * Function name: twa_pci_intr 496 * Description: Interrupt handler. Wrapper for twa_interrupt. 497 * 498 * Input: arg -- ptr to per ctlr structure 499 * Output: None 500 * Return value: None 501 */ 502 static void 503 twa_pci_intr(void *arg) 504 { 505 struct twa_softc *sc = (struct twa_softc *)arg; 506 507 twa_interrupt(sc); 508 } 509 510 511 512 /* 513 * Function name: twa_write_pci_config 514 * Description: Writes to the PCI config space. 515 * 516 * Input: sc -- ptr to per ctlr structure 517 * value -- value to be written 518 * size -- # of bytes to be written 519 * Output: None 520 * Return value: None 521 */ 522 void 523 twa_write_pci_config(struct twa_softc *sc, u_int32_t value, int size) 524 { 525 pci_write_config(sc->twa_bus_dev, PCIR_STATUS, value, size); 526 } 527 528 529 530 /* 531 * Function name: twa_alloc_req_pkts 532 * Description: Allocates memory for, and initializes request pkts, 533 * and queues them in the free queue. 534 * 535 * Input: sc -- ptr to per ctlr structure 536 * num_reqs-- # of request pkts to allocate and initialize. 537 * Output: None 538 * Return value: 0 -- success 539 * non-zero-- failure 540 */ 541 int 542 twa_alloc_req_pkts(struct twa_softc *sc, int num_reqs) 543 { 544 struct twa_request *tr; 545 int i; 546 547 if ((sc->twa_req_buf = malloc(num_reqs * sizeof(struct twa_request), 548 TWA_MALLOC_CLASS, M_NOWAIT)) == NULL) 549 return(ENOMEM); 550 551 /* Create the parent dma tag. */ 552 if (bus_dma_tag_create(NULL, /* parent */ 553 TWA_ALIGNMENT, /* alignment */ 554 0, /* boundary */ 555 BUS_SPACE_MAXADDR, /* lowaddr */ 556 BUS_SPACE_MAXADDR, /* highaddr */ 557 NULL, NULL, /* filter, filterarg */ 558 TWA_Q_LENGTH * 559 (sizeof(struct twa_command_packet)),/* maxsize */ 560 TWA_MAX_SG_ELEMENTS, /* nsegments */ 561 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */ 562 0, /* flags */ 563 NULL, /* lockfunc */ 564 NULL, /* lockfuncarg */ 565 &sc->twa_parent_tag /* tag */)) { 566 twa_printf(sc, "Can't allocate parent DMA tag.\n"); 567 return(ENOMEM); 568 } 569 570 /* Create a bus dma tag for cmd pkts. */ 571 if (bus_dma_tag_create(sc->twa_parent_tag, /* parent */ 572 TWA_ALIGNMENT, /* alignment */ 573 0, /* boundary */ 574 BUS_SPACE_MAXADDR, /* lowaddr */ 575 BUS_SPACE_MAXADDR, /* highaddr */ 576 NULL, NULL, /* filter, filterarg */ 577 TWA_Q_LENGTH * 578 (sizeof(struct twa_command_packet)),/* maxsize */ 579 1, /* nsegments */ 580 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */ 581 0, /* flags */ 582 NULL, /* lockfunc */ 583 NULL, /* lockfuncarg */ 584 &sc->twa_cmd_tag /* tag */)) { 585 twa_printf(sc, "Can't allocate cmd DMA tag.\n"); 586 return(ENOMEM); 587 } 588 589 590 /* Allocate memory for cmd pkts. */ 591 if (bus_dmamem_alloc(sc->twa_cmd_tag, 592 (void *)(&(sc->twa_cmd_pkt_buf)), 593 BUS_DMA_WAITOK, &(sc->twa_cmd_map))) { 594 twa_printf(sc, "Can't allocate memory for cmd pkts.\n"); 595 return(ENOMEM); 596 } 597 598 bus_dmamap_load(sc->twa_cmd_tag, sc->twa_cmd_map, 599 sc->twa_cmd_pkt_buf, 600 num_reqs * sizeof(struct twa_command_packet), 601 twa_setup_request_dmamap, sc, 0); 602 bzero(sc->twa_req_buf, num_reqs * sizeof(struct twa_request)); 603 bzero(sc->twa_cmd_pkt_buf, 604 num_reqs * sizeof(struct twa_command_packet)); 605 606 /* Create a bus dma tag for data buffers. */ 607 if (bus_dma_tag_create(sc->twa_parent_tag, /* parent */ 608 TWA_ALIGNMENT, /* alignment */ 609 0, /* boundary */ 610 BUS_SPACE_MAXADDR, /* lowaddr */ 611 BUS_SPACE_MAXADDR, /* highaddr */ 612 NULL, NULL, /* filter, filterarg */ 613 TWA_MAX_IO_SIZE, /* maxsize */ 614 TWA_MAX_SG_ELEMENTS, /* nsegments */ 615 TWA_MAX_IO_SIZE, /* maxsegsize */ 616 BUS_DMA_ALLOCNOW, /* flags */ 617 busdma_lock_mutex, /* lockfunc */ 618 &Giant, /* lockfuncarg */ 619 &sc->twa_buf_tag /* tag */)) { 620 twa_printf(sc, "Can't allocate buf DMA tag.\n"); 621 return(ENOMEM); 622 } 623 624 for (i = 0; i < num_reqs; i++) { 625 tr = &(sc->twa_req_buf[i]); 626 tr->tr_command = &(sc->twa_cmd_pkt_buf[i]); 627 tr->tr_cmd_phys = sc->twa_cmd_pkt_phys + 628 (i * sizeof(struct twa_command_packet)); 629 tr->tr_request_id = i; 630 tr->tr_sc = sc; 631 sc->twa_lookup[i] = tr; 632 633 /* Create maps for data buffers. */ 634 if (bus_dmamap_create(sc->twa_buf_tag, 0, 635 &tr->tr_buf_map)) 636 return(ENOMEM); 637 638 /* Insert request into the free queue. */ 639 twa_release_request(tr); 640 } 641 return(0); 642 } 643 644 645 646 /* 647 * Function name: twa_fillin_sgl 648 * Description: Fills in the scatter/gather list. 649 * 650 * Input: sgl -- ptr to sg list 651 * segs -- ptr to fill the sg list from 652 * nsegments--# of segments 653 * Output: None 654 * Return value: None 655 */ 656 static void 657 twa_fillin_sgl(struct twa_sg *sgl, bus_dma_segment_t *segs, int nsegments) 658 { 659 int i; 660 661 for (i = 0; i < nsegments; i++) { 662 sgl[i].address = segs[i].ds_addr; 663 sgl[i].length = (u_int32_t)(segs[i].ds_len); 664 } 665 } 666 667 668 669 /* 670 * Function name: twa_setup_data_dmamap 671 * Description: Callback of bus_dmamap_load for the buffer associated 672 * with data. Updates the cmd pkt (size/sgl_entries 673 * fields, as applicable) to reflect the number of sg 674 * elements. 675 * 676 * Input: arg -- ptr to request pkt 677 * segs -- ptr to a list of segment descriptors 678 * nsegments--# of segments 679 * error -- 0 if no errors encountered before callback, 680 * non-zero if errors were encountered 681 * Output: None 682 * Return value: None 683 */ 684 static void 685 twa_setup_data_dmamap(void *arg, bus_dma_segment_t *segs, 686 int nsegments, int error) 687 { 688 struct twa_request *tr = (struct twa_request *)arg; 689 struct twa_command_packet *cmdpkt = tr->tr_command; 690 struct twa_command_9k *cmd9k; 691 union twa_command_7k *cmd7k; 692 u_int8_t sgl_offset; 693 694 twa_dbg_dprint_enter(10, tr->tr_sc); 695 696 tr->tr_flags |= TWA_CMD_MAPPED; 697 if ((tr->tr_flags & TWA_CMD_IN_PROGRESS) && 698 (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)) 699 twa_allow_new_requests(tr->tr_sc, (void *)(tr->tr_private)); 700 701 if (error == EFBIG) { 702 tr->tr_error = error; 703 goto out; 704 } 705 706 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) { 707 cmd9k = &(cmdpkt->command.cmd_pkt_9k); 708 twa_fillin_sgl(&(cmd9k->sg_list[0]), segs, nsegments); 709 cmd9k->sgl_entries += nsegments - 1; 710 } else { 711 /* It's a 7000 command packet. */ 712 cmd7k = &(cmdpkt->command.cmd_pkt_7k); 713 if ((sgl_offset = cmdpkt->command.cmd_pkt_7k.generic.sgl_offset)) 714 twa_fillin_sgl((struct twa_sg *) 715 (((u_int32_t *)cmd7k) + sgl_offset), 716 segs, nsegments); 717 /* Modify the size field, based on sg address size. */ 718 cmd7k->generic.size += 719 ((TWA_64BIT_ADDRESSES ? 3 : 2) * nsegments); 720 } 721 722 if (tr->tr_flags & TWA_CMD_DATA_IN) 723 bus_dmamap_sync(tr->tr_sc->twa_buf_tag, tr->tr_buf_map, 724 BUS_DMASYNC_PREREAD); 725 if (tr->tr_flags & TWA_CMD_DATA_OUT) { 726 /* 727 * If we're using an alignment buffer, and we're 728 * writing data, copy the real data out. 729 */ 730 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) 731 bcopy(tr->tr_real_data, tr->tr_data, tr->tr_real_length); 732 bus_dmamap_sync(tr->tr_sc->twa_buf_tag, tr->tr_buf_map, 733 BUS_DMASYNC_PREWRITE); 734 } 735 error = twa_submit_io(tr); 736 737 out: 738 if (error) { 739 twa_unmap_request(tr); 740 /* 741 * If the caller had been returned EINPROGRESS, and he has 742 * registered a callback for handling completion, the callback 743 * will never get called because we were unable to submit the 744 * request. So, free up the request right here. 745 */ 746 if ((tr->tr_flags & TWA_CMD_IN_PROGRESS) && (tr->tr_callback)) 747 twa_release_request(tr); 748 } 749 } 750 751 752 753 /* 754 * Function name: twa_setup_request_dmamap 755 * Description: Callback of bus_dmamap_load for the buffer associated 756 * with a cmd pkt. 757 * 758 * Input: arg -- ptr to request pkt 759 * segs -- ptr to a list of segment descriptors 760 * nsegments--# of segments 761 * error -- 0 if no errors encountered before callback, 762 * non-zero if errors were encountered 763 * Output: None 764 * Return value: None 765 */ 766 static void 767 twa_setup_request_dmamap(void *arg, bus_dma_segment_t *segs, 768 int nsegments, int error) 769 { 770 struct twa_softc *sc = (struct twa_softc *)arg; 771 772 twa_dbg_dprint_enter(10, sc); 773 774 sc->twa_cmd_pkt_phys = segs[0].ds_addr; 775 } 776 777 778 779 /* 780 * Function name: twa_map_request 781 * Description: Maps a cmd pkt and data associated with it, into 782 * DMA'able memory. 783 * 784 * Input: tr -- ptr to request pkt 785 * Output: None 786 * Return value: 0 -- success 787 * non-zero-- failure 788 */ 789 int 790 twa_map_request(struct twa_request *tr) 791 { 792 struct twa_softc *sc = tr->tr_sc; 793 int error = 0; 794 795 twa_dbg_dprint_enter(10, sc); 796 797 /* If the command involves data, map that too. */ 798 if (tr->tr_data != NULL) { 799 /* 800 * It's sufficient for the data pointer to be 4-byte aligned 801 * to work with 9000. However, if 4-byte aligned addresses 802 * are passed to bus_dmamap_load, we can get back sg elements 803 * that are not 512-byte multiples in size. So, we will let 804 * only those buffers that are 512-byte aligned to pass 805 * through, and bounce the rest, so as to make sure that we 806 * always get back sg elements that are 512-byte multiples 807 * in size. 808 */ 809 if (((vm_offset_t)tr->tr_data % 512) || (tr->tr_length % 512)) { 810 tr->tr_flags |= TWA_CMD_DATA_COPY_NEEDED; 811 tr->tr_real_data = tr->tr_data; /* save original data pointer */ 812 tr->tr_real_length = tr->tr_length; /* save original data length */ 813 tr->tr_length = (tr->tr_length + 511) & ~511; 814 tr->tr_data = malloc(tr->tr_length, TWA_MALLOC_CLASS, M_NOWAIT); 815 if (tr->tr_data == NULL) { 816 twa_printf(sc, "%s: malloc failed\n", __func__); 817 tr->tr_data = tr->tr_real_data; /* restore original data pointer */ 818 tr->tr_length = tr->tr_real_length; /* restore original data length */ 819 return(ENOMEM); 820 } 821 } 822 823 /* 824 * Map the data buffer into bus space and build the s/g list. 825 */ 826 if ((error = bus_dmamap_load(sc->twa_buf_tag, tr->tr_buf_map, 827 tr->tr_data, 828 (bus_size_t)(tr->tr_length), 829 twa_setup_data_dmamap, tr, 830 BUS_DMA_WAITOK))) { 831 if (error == EINPROGRESS) { 832 int s; 833 834 s = splcam(); 835 if (!(tr->tr_flags & TWA_CMD_MAPPED)) { 836 tr->tr_flags |= TWA_CMD_IN_PROGRESS; 837 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) 838 twa_disallow_new_requests(sc); 839 } 840 splx(s); 841 error = 0; 842 } else { 843 /* Free alignment buffer if it was used. */ 844 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) { 845 free(tr->tr_data, TWA_MALLOC_CLASS); 846 tr->tr_data = tr->tr_real_data; /* restore 'real' data pointer */ 847 tr->tr_length = tr->tr_real_length;/* restore 'real' data length */ 848 } 849 } 850 } else 851 error = tr->tr_error; 852 853 } else 854 if ((error = twa_submit_io(tr))) 855 twa_unmap_request(tr); 856 857 return(error); 858 } 859 860 861 862 /* 863 * Function name: twa_unmap_request 864 * Description: Undoes the mapping done by twa_map_request. 865 * 866 * Input: tr -- ptr to request pkt 867 * Output: None 868 * Return value: None 869 */ 870 void 871 twa_unmap_request(struct twa_request *tr) 872 { 873 struct twa_softc *sc = tr->tr_sc; 874 u_int8_t cmd_status; 875 876 twa_dbg_dprint_enter(10, sc); 877 878 /* If the command involved data, unmap that too. */ 879 if (tr->tr_data != NULL) { 880 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) 881 cmd_status = tr->tr_command->command.cmd_pkt_9k.status; 882 else 883 cmd_status = tr->tr_command->command.cmd_pkt_7k.generic.status; 884 885 if (tr->tr_flags & TWA_CMD_DATA_IN) { 886 bus_dmamap_sync(sc->twa_buf_tag, 887 tr->tr_buf_map, BUS_DMASYNC_POSTREAD); 888 889 /* 890 * If we are using a bounce buffer, and we are reading 891 * data, copy the real data in. 892 */ 893 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) 894 if (cmd_status == 0) 895 bcopy(tr->tr_data, tr->tr_real_data, 896 tr->tr_real_length); 897 } 898 if (tr->tr_flags & TWA_CMD_DATA_OUT) 899 bus_dmamap_sync(sc->twa_buf_tag, tr->tr_buf_map, 900 BUS_DMASYNC_POSTWRITE); 901 902 bus_dmamap_unload(sc->twa_buf_tag, tr->tr_buf_map); 903 } 904 905 /* Free alignment buffer if it was used. */ 906 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) { 907 free(tr->tr_data, TWA_MALLOC_CLASS); 908 tr->tr_data = tr->tr_real_data; /* restore 'real' data pointer */ 909 tr->tr_length = tr->tr_real_length;/* restore 'real' data length */ 910 } 911 } 912 913 914 915 #ifdef TWA_DEBUG 916 void twa_report(void); 917 void twa_reset_stats(void); 918 void twa_print_request(struct twa_request *tr, int req_type); 919 920 921 922 /* 923 * Function name: twa_report 924 * Description: For being called from ddb. Prints controller stats, 925 * and requests, if any, that are in the wrong queue. 926 * 927 * Input: None 928 * Output: None 929 * Return value: None 930 */ 931 void 932 twa_report(void) 933 { 934 struct twa_softc *sc; 935 struct twa_request *tr; 936 int s; 937 int i; 938 939 s = splcam(); 940 for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) { 941 twa_print_controller(sc); 942 TAILQ_FOREACH(tr, &sc->twa_busy, tr_link) 943 twa_print_request(tr, TWA_CMD_BUSY); 944 TAILQ_FOREACH(tr, &sc->twa_complete, tr_link) 945 twa_print_request(tr, TWA_CMD_COMPLETE); 946 } 947 splx(s); 948 } 949 950 951 952 /* 953 * Function name: twa_reset_stats 954 * Description: For being called from ddb. 955 * Resets some controller stats. 956 * 957 * Input: None 958 * Output: None 959 * Return value: None 960 */ 961 void 962 twa_reset_stats(void) 963 { 964 struct twa_softc *sc; 965 int s; 966 int i; 967 968 s = splcam(); 969 for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) { 970 sc->twa_qstats[TWAQ_FREE].q_max = 0; 971 sc->twa_qstats[TWAQ_BUSY].q_max = 0; 972 sc->twa_qstats[TWAQ_PENDING].q_max = 0; 973 sc->twa_qstats[TWAQ_COMPLETE].q_max = 0; 974 } 975 splx(s); 976 } 977 978 979 980 /* 981 * Function name: twa_print_request 982 * Description: Prints a given request if it's in the wrong queue. 983 * 984 * Input: tr -- ptr to request pkt 985 * req_type-- expected status of the given request 986 * Output: None 987 * Return value: None 988 */ 989 void 990 twa_print_request(struct twa_request *tr, int req_type) 991 { 992 struct twa_softc *sc = tr->tr_sc; 993 struct twa_command_packet *cmdpkt = tr->tr_command; 994 struct twa_command_9k *cmd9k; 995 union twa_command_7k *cmd7k; 996 u_int8_t *cdb; 997 998 if (tr->tr_status != req_type) { 999 twa_printf(sc, "Invalid %s request %p in queue! req_type = %x, queue_type = %x\n", 1000 (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) ? "INTERNAL" : "EXTERNAL", 1001 tr, tr->tr_status, req_type); 1002 1003 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) { 1004 cmd9k = &(cmdpkt->command.cmd_pkt_9k); 1005 twa_printf(sc, "9K cmd = %x %x %x %x %x %x %x %jx %x\n", 1006 cmd9k->command.opcode, 1007 cmd9k->command.reserved, 1008 cmd9k->unit, 1009 cmd9k->request_id, 1010 cmd9k->status, 1011 cmd9k->sgl_offset, 1012 cmd9k->sgl_entries, 1013 (uintmax_t)(cmd9k->sg_list[0].address), 1014 cmd9k->sg_list[0].length); 1015 cdb = (u_int8_t *)(cmdpkt->command.cmd_pkt_9k.cdb); 1016 twa_printf(sc, "cdb = %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x\n", 1017 cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], 1018 cdb[8], cdb[9], cdb[10], cdb[11], cdb[12], cdb[13], cdb[14], cdb[15]); 1019 } else { 1020 cmd7k = &(cmdpkt->command.cmd_pkt_7k); 1021 twa_printf(sc, "7K cmd = %x %x %x %x %x %x %x %x %x\n", 1022 cmd7k->generic.opcode, 1023 cmd7k->generic.sgl_offset, 1024 cmd7k->generic.size, 1025 cmd7k->generic.request_id, 1026 cmd7k->generic.unit, 1027 cmd7k->generic.host_id, 1028 cmd7k->generic.status, 1029 cmd7k->generic.flags, 1030 cmd7k->generic.count); 1031 } 1032 1033 twa_printf(sc, "cmd_phys=0x%jx data=%p length=0x%x\n", 1034 (uintmax_t)(tr->tr_cmd_phys), tr->tr_data, 1035 tr->tr_length); 1036 twa_printf(sc, "req_id=0x%x flags=0x%x callback=%p private=%p\n", 1037 tr->tr_request_id, tr->tr_flags, 1038 tr->tr_callback, tr->tr_private); 1039 } 1040 } 1041 #endif
Cache object: cb06d6a3433c330189edf5f466b376c2
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]