1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <sys/errno.h> 28 #include <sys/types.h> 29 #include <sys/conf.h> 30 #include <sys/kmem.h> 31 #include <sys/ddi.h> 32 #include <sys/stat.h> 33 #include <sys/sunddi.h> 34 #include <sys/file.h> 35 #include <sys/open.h> 36 #include <sys/modctl.h> 37 #include <sys/ddi_impldefs.h> 38 #include <sys/sysmacros.h> 39 40 #include <sys/ioat.h> 41 42 static int ioat_open(dev_t *devp, int flag, int otyp, cred_t *cred); 43 static int ioat_close(dev_t devp, int flag, int otyp, cred_t *cred); 44 static int ioat_attach(dev_info_t *devi, ddi_attach_cmd_t cmd); 45 static int ioat_detach(dev_info_t *devi, ddi_detach_cmd_t cmd); 46 static int ioat_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, 47 void **result); 48 static int ioat_quiesce(dev_info_t *dip); 49 50 static struct cb_ops ioat_cb_ops = { 51 ioat_open, /* cb_open */ 52 ioat_close, /* cb_close */ 53 nodev, /* cb_strategy */ 54 nodev, /* cb_print */ 55 nodev, /* cb_dump */ 56 nodev, /* cb_read */ 57 nodev, /* cb_write */ 58 ioat_ioctl, /* cb_ioctl */ 59 nodev, /* cb_devmap */ 60 nodev, /* cb_mmap */ 61 nodev, /* cb_segmap */ 62 nochpoll, /* cb_chpoll */ 63 ddi_prop_op, /* cb_prop_op */ 64 NULL, /* cb_stream */ 65 D_NEW | D_MP | D_64BIT | D_DEVMAP, /* cb_flag */ 66 CB_REV 67 }; 68 69 static struct dev_ops ioat_dev_ops = { 70 DEVO_REV, /* devo_rev */ 71 0, /* devo_refcnt */ 72 ioat_getinfo, /* devo_getinfo */ 73 nulldev, /* devo_identify */ 74 nulldev, /* devo_probe */ 75 ioat_attach, /* devo_attach */ 76 ioat_detach, /* devo_detach */ 77 nodev, /* devo_reset */ 78 &ioat_cb_ops, /* devo_cb_ops */ 79 NULL, /* devo_bus_ops */ 80 NULL, /* devo_power */ 81 ioat_quiesce, /* devo_quiesce */ 82 }; 83 84 static struct modldrv ioat_modldrv = { 85 &mod_driverops, /* Type of module. This one is a driver */ 86 "ioat driver", /* Name of the module. */ 87 &ioat_dev_ops, /* driver ops */ 88 }; 89 90 static struct modlinkage ioat_modlinkage = { 91 MODREV_1, 92 (void *) &ioat_modldrv, 93 NULL 94 }; 95 96 97 void *ioat_statep; 98 99 static int ioat_chip_init(ioat_state_t *state); 100 static void ioat_chip_fini(ioat_state_t *state); 101 static int ioat_drv_init(ioat_state_t *state); 102 static void ioat_drv_fini(ioat_state_t *state); 103 static uint_t ioat_isr(caddr_t parm); 104 static void ioat_intr_enable(ioat_state_t *state); 105 static void ioat_intr_disable(ioat_state_t *state); 106 void ioat_detach_finish(ioat_state_t *state); 107 108 109 ddi_device_acc_attr_t ioat_acc_attr = { 110 DDI_DEVICE_ATTR_V0, /* devacc_attr_version */ 111 DDI_NEVERSWAP_ACC, /* devacc_attr_endian_flags */ 112 DDI_STORECACHING_OK_ACC, /* devacc_attr_dataorder */ 113 DDI_DEFAULT_ACC /* devacc_attr_access */ 114 }; 115 116 /* dcopy callback interface */ 117 dcopy_device_cb_t ioat_cb = { 118 DCOPY_DEVICECB_V0, 119 0, /* reserved */ 120 ioat_channel_alloc, 121 ioat_channel_free, 122 ioat_cmd_alloc, 123 ioat_cmd_free, 124 ioat_cmd_post, 125 ioat_cmd_poll, 126 ioat_unregister_complete 127 }; 128 129 /* 130 * _init() 131 */ 132 int 133 _init(void) 134 { 135 int e; 136 137 e = ddi_soft_state_init(&ioat_statep, sizeof (ioat_state_t), 1); 138 if (e != 0) { 139 return (e); 140 } 141 142 e = mod_install(&ioat_modlinkage); 143 if (e != 0) { 144 ddi_soft_state_fini(&ioat_statep); 145 return (e); 146 } 147 148 return (0); 149 } 150 151 /* 152 * _info() 153 */ 154 int 155 _info(struct modinfo *modinfop) 156 { 157 return (mod_info(&ioat_modlinkage, modinfop)); 158 } 159 160 /* 161 * _fini() 162 */ 163 int 164 _fini(void) 165 { 166 int e; 167 168 e = mod_remove(&ioat_modlinkage); 169 if (e != 0) { 170 return (e); 171 } 172 173 ddi_soft_state_fini(&ioat_statep); 174 175 return (0); 176 } 177 178 /* 179 * ioat_attach() 180 */ 181 static int 182 ioat_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 183 { 184 ioat_state_t *state; 185 int instance; 186 int e; 187 188 189 switch (cmd) { 190 case DDI_ATTACH: 191 break; 192 193 case DDI_RESUME: 194 instance = ddi_get_instance(dip); 195 state = ddi_get_soft_state(ioat_statep, instance); 196 if (state == NULL) { 197 return (DDI_FAILURE); 198 } 199 e = ioat_channel_resume(state); 200 if (e != DDI_SUCCESS) { 201 return (DDI_FAILURE); 202 } 203 ioat_intr_enable(state); 204 return (DDI_SUCCESS); 205 206 default: 207 return (DDI_FAILURE); 208 } 209 210 instance = ddi_get_instance(dip); 211 e = ddi_soft_state_zalloc(ioat_statep, instance); 212 if (e != DDI_SUCCESS) { 213 return (DDI_FAILURE); 214 } 215 state = ddi_get_soft_state(ioat_statep, instance); 216 if (state == NULL) { 217 goto attachfail_get_soft_state; 218 } 219 220 state->is_dip = dip; 221 state->is_instance = instance; 222 223 /* setup the registers, save away some device info */ 224 e = ioat_chip_init(state); 225 if (e != DDI_SUCCESS) { 226 goto attachfail_chip_init; 227 } 228 229 /* initialize driver state, must be after chip init */ 230 e = ioat_drv_init(state); 231 if (e != DDI_SUCCESS) { 232 goto attachfail_drv_init; 233 } 234 235 /* create the minor node (for the ioctl) */ 236 e = ddi_create_minor_node(dip, "ioat", S_IFCHR, instance, DDI_PSEUDO, 237 0); 238 if (e != DDI_SUCCESS) { 239 goto attachfail_minor_node; 240 } 241 242 /* Enable device interrupts */ 243 ioat_intr_enable(state); 244 245 /* Report that driver was loaded */ 246 ddi_report_dev(dip); 247 248 /* register with dcopy */ 249 e = dcopy_device_register(state, &state->is_deviceinfo, 250 &state->is_device_handle); 251 if (e != DCOPY_SUCCESS) { 252 goto attachfail_register; 253 } 254 255 return (DDI_SUCCESS); 256 257 attachfail_register: 258 ioat_intr_disable(state); 259 ddi_remove_minor_node(dip, NULL); 260 attachfail_minor_node: 261 ioat_drv_fini(state); 262 attachfail_drv_init: 263 ioat_chip_fini(state); 264 attachfail_chip_init: 265 attachfail_get_soft_state: 266 (void) ddi_soft_state_free(ioat_statep, instance); 267 268 return (DDI_FAILURE); 269 } 270 271 /* 272 * ioat_detach() 273 */ 274 static int 275 ioat_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 276 { 277 ioat_state_t *state; 278 int instance; 279 int e; 280 281 282 instance = ddi_get_instance(dip); 283 state = ddi_get_soft_state(ioat_statep, instance); 284 if (state == NULL) { 285 return (DDI_FAILURE); 286 } 287 288 switch (cmd) { 289 case DDI_DETACH: 290 break; 291 292 case DDI_SUSPEND: 293 ioat_channel_suspend(state); 294 return (DDI_SUCCESS); 295 296 default: 297 return (DDI_FAILURE); 298 } 299 300 /* 301 * try to unregister from dcopy. Since this driver doesn't follow the 302 * traditional parent/child model, we may still be in use so we can't 303 * detach yet. 304 */ 305 e = dcopy_device_unregister(&state->is_device_handle); 306 if (e != DCOPY_SUCCESS) { 307 if (e == DCOPY_PENDING) { 308 cmn_err(CE_NOTE, "device busy, performing asynchronous" 309 " detach\n"); 310 } 311 return (DDI_FAILURE); 312 } 313 314 ioat_detach_finish(state); 315 316 return (DDI_SUCCESS); 317 } 318 319 /* 320 * ioat_getinfo() 321 */ 322 /*ARGSUSED*/ 323 static int 324 ioat_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 325 { 326 ioat_state_t *state; 327 int instance; 328 dev_t dev; 329 int e; 330 331 332 dev = (dev_t)arg; 333 instance = getminor(dev); 334 335 switch (cmd) { 336 case DDI_INFO_DEVT2DEVINFO: 337 state = ddi_get_soft_state(ioat_statep, instance); 338 if (state == NULL) { 339 return (DDI_FAILURE); 340 } 341 *result = (void *)state->is_dip; 342 e = DDI_SUCCESS; 343 break; 344 345 case DDI_INFO_DEVT2INSTANCE: 346 *result = (void *)(uintptr_t)instance; 347 e = DDI_SUCCESS; 348 break; 349 350 default: 351 e = DDI_FAILURE; 352 break; 353 } 354 355 return (e); 356 } 357 358 359 /* 360 * ioat_open() 361 */ 362 /*ARGSUSED*/ 363 static int 364 ioat_open(dev_t *devp, int flag, int otyp, cred_t *cred) 365 { 366 ioat_state_t *state; 367 int instance; 368 369 instance = getminor(*devp); 370 state = ddi_get_soft_state(ioat_statep, instance); 371 if (state == NULL) { 372 return (ENXIO); 373 } 374 375 return (0); 376 } 377 378 379 /* 380 * ioat_close() 381 */ 382 /*ARGSUSED*/ 383 static int 384 ioat_close(dev_t devp, int flag, int otyp, cred_t *cred) 385 { 386 return (0); 387 } 388 389 390 /* 391 * ioat_chip_init() 392 */ 393 static int 394 ioat_chip_init(ioat_state_t *state) 395 { 396 ddi_device_acc_attr_t attr; 397 int e; 398 399 400 attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; 401 attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC; 402 attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; 403 404 e = ddi_regs_map_setup(state->is_dip, 1, (caddr_t *)&state->is_genregs, 405 0, 0, &attr, &state->is_reg_handle); 406 if (e != DDI_SUCCESS) { 407 goto chipinitfail_regsmap; 408 } 409 410 /* save away ioat chip info */ 411 state->is_num_channels = (uint_t)ddi_get8(state->is_reg_handle, 412 &state->is_genregs[IOAT_CHANCNT]); 413 414 /* 415 * If we get a bogus value, something is wrong with the H/W, fail to 416 * attach. 417 */ 418 if (state->is_num_channels == 0) { 419 goto chipinitfail_numchan; 420 } 421 422 state->is_maxxfer = (uint_t)ddi_get8(state->is_reg_handle, 423 &state->is_genregs[IOAT_XFERCAP]); 424 state->is_chanoff = (uintptr_t)ddi_get16(state->is_reg_handle, 425 (uint16_t *)&state->is_genregs[IOAT_PERPORT_OFF]); 426 state->is_cbver = (uint_t)ddi_get8(state->is_reg_handle, 427 &state->is_genregs[IOAT_CBVER]); 428 state->is_intrdelay = (uint_t)ddi_get16(state->is_reg_handle, 429 (uint16_t *)&state->is_genregs[IOAT_INTRDELAY]); 430 state->is_status = (uint_t)ddi_get16(state->is_reg_handle, 431 (uint16_t *)&state->is_genregs[IOAT_CSSTATUS]); 432 state->is_capabilities = (uint_t)ddi_get32(state->is_reg_handle, 433 (uint32_t *)&state->is_genregs[IOAT_DMACAPABILITY]); 434 435 if (state->is_cbver & 0x10) { 436 state->is_ver = IOAT_CBv1; 437 } else if (state->is_cbver & 0x20) { 438 state->is_ver = IOAT_CBv2; 439 } else { 440 goto chipinitfail_version; 441 } 442 443 return (DDI_SUCCESS); 444 445 chipinitfail_version: 446 chipinitfail_numchan: 447 ddi_regs_map_free(&state->is_reg_handle); 448 chipinitfail_regsmap: 449 return (DDI_FAILURE); 450 } 451 452 453 /* 454 * ioat_chip_fini() 455 */ 456 static void 457 ioat_chip_fini(ioat_state_t *state) 458 { 459 ddi_regs_map_free(&state->is_reg_handle); 460 } 461 462 463 /* 464 * ioat_drv_init() 465 */ 466 static int 467 ioat_drv_init(ioat_state_t *state) 468 { 469 ddi_acc_handle_t handle; 470 int e; 471 472 473 mutex_init(&state->is_mutex, NULL, MUTEX_DRIVER, NULL); 474 475 state->is_deviceinfo.di_dip = state->is_dip; 476 state->is_deviceinfo.di_num_dma = state->is_num_channels; 477 state->is_deviceinfo.di_maxxfer = state->is_maxxfer; 478 state->is_deviceinfo.di_capabilities = state->is_capabilities; 479 state->is_deviceinfo.di_cb = &ioat_cb; 480 481 e = pci_config_setup(state->is_dip, &handle); 482 if (e != DDI_SUCCESS) { 483 goto drvinitfail_config_setup; 484 } 485 486 /* read in Vendor ID */ 487 state->is_deviceinfo.di_id = (uint64_t)pci_config_get16(handle, 0); 488 state->is_deviceinfo.di_id = state->is_deviceinfo.di_id << 16; 489 490 /* read in Device ID */ 491 state->is_deviceinfo.di_id |= (uint64_t)pci_config_get16(handle, 2); 492 state->is_deviceinfo.di_id = state->is_deviceinfo.di_id << 32; 493 494 /* Add in chipset version */ 495 state->is_deviceinfo.di_id |= (uint64_t)state->is_cbver; 496 pci_config_teardown(&handle); 497 498 e = ddi_intr_hilevel(state->is_dip, 0); 499 if (e != 0) { 500 cmn_err(CE_WARN, "hilevel interrupt not supported\n"); 501 goto drvinitfail_hilevel; 502 } 503 504 /* we don't support MSIs for v2 yet */ 505 e = ddi_add_intr(state->is_dip, 0, NULL, NULL, ioat_isr, 506 (caddr_t)state); 507 if (e != DDI_SUCCESS) { 508 goto drvinitfail_add_intr; 509 } 510 511 e = ddi_get_iblock_cookie(state->is_dip, 0, &state->is_iblock_cookie); 512 if (e != DDI_SUCCESS) { 513 goto drvinitfail_iblock_cookie; 514 } 515 516 e = ioat_channel_init(state); 517 if (e != DDI_SUCCESS) { 518 goto drvinitfail_channel_init; 519 } 520 521 return (DDI_SUCCESS); 522 523 drvinitfail_channel_init: 524 drvinitfail_iblock_cookie: 525 ddi_remove_intr(state->is_dip, 0, state->is_iblock_cookie); 526 drvinitfail_add_intr: 527 drvinitfail_hilevel: 528 drvinitfail_config_setup: 529 mutex_destroy(&state->is_mutex); 530 531 return (DDI_FAILURE); 532 } 533 534 535 /* 536 * ioat_drv_fini() 537 */ 538 static void 539 ioat_drv_fini(ioat_state_t *state) 540 { 541 ioat_channel_fini(state); 542 ddi_remove_intr(state->is_dip, 0, state->is_iblock_cookie); 543 mutex_destroy(&state->is_mutex); 544 } 545 546 547 /* 548 * ioat_unregister_complete() 549 */ 550 void 551 ioat_unregister_complete(void *device_private, int status) 552 { 553 ioat_state_t *state; 554 555 556 state = device_private; 557 558 if (status != DCOPY_SUCCESS) { 559 cmn_err(CE_WARN, "asynchronous detach aborted\n"); 560 return; 561 } 562 563 cmn_err(CE_CONT, "detach completing\n"); 564 ioat_detach_finish(state); 565 } 566 567 568 /* 569 * ioat_detach_finish() 570 */ 571 void 572 ioat_detach_finish(ioat_state_t *state) 573 { 574 ioat_intr_disable(state); 575 ddi_remove_minor_node(state->is_dip, NULL); 576 ioat_drv_fini(state); 577 ioat_chip_fini(state); 578 (void) ddi_soft_state_free(ioat_statep, state->is_instance); 579 } 580 581 582 /* 583 * ioat_intr_enable() 584 */ 585 static void 586 ioat_intr_enable(ioat_state_t *state) 587 { 588 uint32_t intr_status; 589 590 591 /* Clear any pending interrupts */ 592 intr_status = ddi_get32(state->is_reg_handle, 593 (uint32_t *)&state->is_genregs[IOAT_ATTNSTATUS]); 594 if (intr_status != 0) { 595 ddi_put32(state->is_reg_handle, 596 (uint32_t *)&state->is_genregs[IOAT_ATTNSTATUS], 597 intr_status); 598 } 599 600 /* Enable interrupts on the device */ 601 ddi_put8(state->is_reg_handle, &state->is_genregs[IOAT_INTRCTL], 602 IOAT_INTRCTL_MASTER_EN); 603 } 604 605 606 /* 607 * ioat_intr_disable() 608 */ 609 static void 610 ioat_intr_disable(ioat_state_t *state) 611 { 612 /* 613 * disable interrupts on the device. A read of the interrupt control 614 * register clears the enable bit. 615 */ 616 (void) ddi_get8(state->is_reg_handle, 617 &state->is_genregs[IOAT_INTRCTL]); 618 } 619 620 621 /* 622 * ioat_isr() 623 */ 624 static uint_t 625 ioat_isr(caddr_t parm) 626 { 627 uint32_t intr_status; 628 ioat_state_t *state; 629 uint8_t intrctrl; 630 uint32_t chan; 631 uint_t r; 632 int i; 633 634 state = (ioat_state_t *)parm; 635 636 intrctrl = ddi_get8(state->is_reg_handle, 637 &state->is_genregs[IOAT_INTRCTL]); 638 /* master interrupt enable should always be set */ 639 ASSERT(intrctrl & IOAT_INTRCTL_MASTER_EN); 640 641 /* If the interrupt status bit isn't set, it's not ours */ 642 if (!(intrctrl & IOAT_INTRCTL_INTR_STAT)) { 643 /* re-set master interrupt enable (since it clears on read) */ 644 ddi_put8(state->is_reg_handle, 645 &state->is_genregs[IOAT_INTRCTL], intrctrl); 646 return (DDI_INTR_UNCLAIMED); 647 } 648 649 /* see which channels generated the interrupt */ 650 intr_status = ddi_get32(state->is_reg_handle, 651 (uint32_t *)&state->is_genregs[IOAT_ATTNSTATUS]); 652 653 /* call the intr handler for the channels */ 654 r = DDI_INTR_UNCLAIMED; 655 chan = 1; 656 for (i = 0; i < state->is_num_channels; i++) { 657 if (intr_status & chan) { 658 ioat_channel_intr(&state->is_channel[i]); 659 r = DDI_INTR_CLAIMED; 660 } 661 chan = chan << 1; 662 } 663 664 /* 665 * if interrupt status bit was set, there should have been an 666 * attention status bit set too. 667 */ 668 ASSERT(r == DDI_INTR_CLAIMED); 669 670 /* re-set master interrupt enable (since it clears on read) */ 671 ddi_put8(state->is_reg_handle, &state->is_genregs[IOAT_INTRCTL], 672 intrctrl); 673 674 return (r); 675 } 676 677 static int 678 ioat_quiesce(dev_info_t *dip) 679 { 680 ioat_state_t *state; 681 int instance; 682 683 instance = ddi_get_instance(dip); 684 state = ddi_get_soft_state(ioat_statep, instance); 685 if (state == NULL) { 686 return (DDI_FAILURE); 687 } 688 689 ioat_intr_disable(state); 690 ioat_channel_quiesce(state); 691 692 return (DDI_SUCCESS); 693 } 694