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 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * audioixp Audio Driver 28 * 29 * This driver supports audio hardware integrated in ATI IXP400 chipset. 30 * 31 * The IXP400 audio core is an AC'97 controller, which has independent 32 * channels for PCM in, PCM out. The AC'97 controller is a PCI bus master 33 * with scatter/gather support. Each channel has a DMA engine. Currently, 34 * we use only the PCM in and PCM out channels. Each DMA engine uses one 35 * buffer descriptor list. Each entry contains a pointer to a data buffer, 36 * status, length of the buffer being pointed to and the pointer to the next 37 * entry. Length of the buffer is in number of bytes. Interrupt will be 38 * triggered each time a entry is processed by hardware. 39 * 40 * System power management is not yet supported by the driver. 41 * 42 * NOTE: 43 * This driver depends on the misc/ac97 and drv/audio modules being 44 * loaded first. 45 */ 46 #include <sys/types.h> 47 #include <sys/modctl.h> 48 #include <sys/kmem.h> 49 #include <sys/conf.h> 50 #include <sys/ddi.h> 51 #include <sys/sunddi.h> 52 #include <sys/pci.h> 53 #include <sys/note.h> 54 #include <sys/audio/audio_driver.h> 55 #include <sys/audio/ac97.h> 56 #include "audioixp.h" 57 58 /* 59 * Module linkage routines for the kernel 60 */ 61 static int audioixp_ddi_attach(dev_info_t *, ddi_attach_cmd_t); 62 static int audioixp_ddi_detach(dev_info_t *, ddi_detach_cmd_t); 63 static int audioixp_quiesce(dev_info_t *); 64 static int audioixp_resume(dev_info_t *); 65 static int audioixp_suspend(dev_info_t *); 66 67 /* 68 * Entry point routine prototypes 69 */ 70 static int audioixp_open(void *, int, unsigned *, caddr_t *); 71 static void audioixp_close(void *); 72 static int audioixp_start(void *); 73 static void audioixp_stop(void *); 74 static int audioixp_format(void *); 75 static int audioixp_channels(void *); 76 static int audioixp_rate(void *); 77 static uint64_t audioixp_count(void *); 78 static void audioixp_sync(void *, unsigned); 79 80 static audio_engine_ops_t audioixp_engine_ops = { 81 AUDIO_ENGINE_VERSION, 82 audioixp_open, 83 audioixp_close, 84 audioixp_start, 85 audioixp_stop, 86 audioixp_count, 87 audioixp_format, 88 audioixp_channels, 89 audioixp_rate, 90 audioixp_sync, 91 NULL, 92 NULL, 93 NULL 94 }; 95 96 /* 97 * We drive audioixp in stereo only, so we don't want to display controls 98 * that are used for multichannel codecs. Note that this multichannel 99 * configuration limitation is a problem for audioixp devices. 100 */ 101 const char *audioixp_remove_ac97[] = { 102 AUDIO_CTRL_ID_CENTER, 103 AUDIO_CTRL_ID_LFE, 104 AUDIO_CTRL_ID_SURROUND, 105 AUDIO_CTRL_ID_JACK1, 106 AUDIO_CTRL_ID_JACK2, 107 }; 108 109 /* 110 * Local Routine Prototypes 111 */ 112 static int audioixp_attach(dev_info_t *); 113 static int audioixp_detach(dev_info_t *); 114 static int audioixp_alloc_port(audioixp_state_t *, int); 115 static void audioixp_update_port(audioixp_port_t *); 116 117 static int audioixp_codec_sync(audioixp_state_t *); 118 static void audioixp_wr97(void *, uint8_t, uint16_t); 119 static uint16_t audioixp_rd97(void *, uint8_t); 120 static int audioixp_reset_ac97(audioixp_state_t *); 121 static int audioixp_map_regs(audioixp_state_t *); 122 static void audioixp_unmap_regs(audioixp_state_t *); 123 static int audioixp_chip_init(audioixp_state_t *); 124 static void audioixp_destroy(audioixp_state_t *); 125 126 /* 127 * Global variables, but used only by this file. 128 */ 129 130 /* 131 * DDI Structures 132 */ 133 134 /* Device operations structure */ 135 static struct dev_ops audioixp_dev_ops = { 136 DEVO_REV, /* devo_rev */ 137 0, /* devo_refcnt */ 138 NULL, /* devo_getinfo */ 139 nulldev, /* devo_identify - obsolete */ 140 nulldev, /* devo_probe */ 141 audioixp_ddi_attach, /* devo_attach */ 142 audioixp_ddi_detach, /* devo_detach */ 143 nodev, /* devo_reset */ 144 NULL, /* devi_cb_ops */ 145 NULL, /* devo_bus_ops */ 146 NULL, /* devo_power */ 147 audioixp_quiesce, /* devo_quiesce */ 148 }; 149 150 /* Linkage structure for loadable drivers */ 151 static struct modldrv audioixp_modldrv = { 152 &mod_driverops, /* drv_modops */ 153 IXP_MOD_NAME, /* drv_linkinfo */ 154 &audioixp_dev_ops, /* drv_dev_ops */ 155 }; 156 157 /* Module linkage structure */ 158 static struct modlinkage audioixp_modlinkage = { 159 MODREV_1, /* ml_rev */ 160 (void *)&audioixp_modldrv, /* ml_linkage */ 161 NULL /* NULL terminates the list */ 162 }; 163 164 /* 165 * device access attributes for register mapping 166 */ 167 static struct ddi_device_acc_attr dev_attr = { 168 DDI_DEVICE_ATTR_V0, 169 DDI_STRUCTURE_LE_ACC, 170 DDI_STRICTORDER_ACC 171 }; 172 static struct ddi_device_acc_attr buf_attr = { 173 DDI_DEVICE_ATTR_V0, 174 DDI_NEVERSWAP_ACC, 175 DDI_STRICTORDER_ACC 176 }; 177 178 /* 179 * DMA attributes of buffer descriptor list 180 */ 181 static ddi_dma_attr_t bdlist_dma_attr = { 182 DMA_ATTR_V0, /* version */ 183 0, /* addr_lo */ 184 0xffffffff, /* addr_hi */ 185 0x0000ffff, /* count_max */ 186 8, /* align, BDL must be aligned on a 8-byte boundary */ 187 0x3c, /* burstsize */ 188 8, /* minxfer, set to the size of a BDlist entry */ 189 0x0000ffff, /* maxxfer */ 190 0x00000fff, /* seg, set to the RAM pagesize of intel platform */ 191 1, /* sgllen, there's no scatter-gather list */ 192 8, /* granular, set to the value of minxfer */ 193 0 /* flags, use virtual address */ 194 }; 195 196 /* 197 * DMA attributes of buffers to be used to receive/send audio data 198 */ 199 static ddi_dma_attr_t sample_buf_dma_attr = { 200 DMA_ATTR_V0, 201 0, /* addr_lo */ 202 0xffffffff, /* addr_hi */ 203 0x0001fffe, /* count_max */ 204 4, /* align, data buffer is aligned on a 2-byte boundary */ 205 0x3c, /* burstsize */ 206 4, /* minxfer, set to the size of a sample data */ 207 0x0001ffff, /* maxxfer */ 208 0x0001ffff, /* seg */ 209 1, /* sgllen, no scatter-gather */ 210 4, /* granular, set to the value of minxfer */ 211 0, /* flags, use virtual address */ 212 }; 213 214 /* 215 * _init() 216 * 217 * Description: 218 * Driver initialization, called when driver is first loaded. 219 * This is how access is initially given to all the static structures. 220 * 221 * Arguments: 222 * None 223 * 224 * Returns: 225 * ddi_soft_state_init() status, see ddi_soft_state_init(9f), or 226 * mod_install() status, see mod_install(9f) 227 */ 228 int 229 _init(void) 230 { 231 int error; 232 233 audio_init_ops(&audioixp_dev_ops, IXP_NAME); 234 235 if ((error = mod_install(&audioixp_modlinkage)) != 0) { 236 audio_fini_ops(&audioixp_dev_ops); 237 } 238 239 return (error); 240 } 241 242 /* 243 * _fini() 244 * 245 * Description: 246 * Module de-initialization, called when the driver is to be unloaded. 247 * 248 * Arguments: 249 * None 250 * 251 * Returns: 252 * mod_remove() status, see mod_remove(9f) 253 */ 254 int 255 _fini(void) 256 { 257 int error; 258 259 if ((error = mod_remove(&audioixp_modlinkage)) != 0) { 260 return (error); 261 } 262 263 audio_fini_ops(&audioixp_dev_ops); 264 265 return (0); 266 } 267 268 /* 269 * _info() 270 * 271 * Description: 272 * Module information, returns information about the driver. 273 * 274 * Arguments: 275 * modinfo *modinfop Pointer to the opaque modinfo structure 276 * 277 * Returns: 278 * mod_info() status, see mod_info(9f) 279 */ 280 int 281 _info(struct modinfo *modinfop) 282 { 283 return (mod_info(&audioixp_modlinkage, modinfop)); 284 } 285 286 287 /* ******************* Driver Entry Points ********************************* */ 288 289 /* 290 * audioixp_ddi_attach() 291 * 292 * Description: 293 * Attach an instance of the audioixp driver. 294 * 295 * Arguments: 296 * dev_info_t *dip Pointer to the device's dev_info struct 297 * ddi_attach_cmd_t cmd Attach command 298 * 299 * Returns: 300 * DDI_SUCCESS The driver was initialized properly 301 * DDI_FAILURE The driver couldn't be initialized properly 302 */ 303 static int 304 audioixp_ddi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 305 { 306 switch (cmd) { 307 case DDI_ATTACH: 308 return (audioixp_attach(dip)); 309 310 /* 311 * now, no suspend/resume supported. we'll do it in the future. 312 */ 313 case DDI_RESUME: 314 return (audioixp_resume(dip)); 315 default: 316 return (DDI_FAILURE); 317 } 318 } 319 320 /* 321 * audioixp_ddi_detach() 322 * 323 * Description: 324 * Detach an instance of the audioixp driver. 325 * 326 * Arguments: 327 * dev_info_t *dip Pointer to the device's dev_info struct 328 * ddi_detach_cmd_t cmd Detach command 329 * 330 * Returns: 331 * DDI_SUCCESS The driver was detached 332 * DDI_FAILURE The driver couldn't be detached 333 */ 334 static int 335 audioixp_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 336 { 337 switch (cmd) { 338 case DDI_DETACH: 339 return (audioixp_detach(dip)); 340 341 /* 342 * now, no suspend/resume supported. we'll do it in the future. 343 */ 344 case DDI_SUSPEND: 345 return (audioixp_suspend(dip)); 346 347 default: 348 return (DDI_FAILURE); 349 } 350 } 351 352 /* 353 * quiesce(9E) entry point. 354 * 355 * This function is called when the system is single-threaded at high 356 * PIL with preemption disabled. Therefore, this function must not be blocked. 357 * 358 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure. 359 * DDI_FAILURE indicates an error condition and should almost never happen. 360 */ 361 static int 362 audioixp_quiesce(dev_info_t *dip) 363 { 364 audioixp_state_t *statep; 365 366 statep = ddi_get_driver_private(dip); 367 ASSERT(statep != NULL); 368 369 /* stop DMA engines */ 370 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT); 371 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT_DMA); 372 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN); 373 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN_DMA); 374 375 return (DDI_SUCCESS); 376 } 377 378 static int 379 audioixp_suspend(dev_info_t *dip) 380 { 381 audioixp_state_t *statep; 382 383 statep = ddi_get_driver_private(dip); 384 ASSERT(statep != NULL); 385 386 audio_dev_suspend(statep->adev); 387 388 return (DDI_SUCCESS); 389 } 390 391 static int 392 audioixp_resume(dev_info_t *dip) 393 { 394 audioixp_state_t *statep; 395 396 statep = ddi_get_driver_private(dip); 397 ASSERT(statep != NULL); 398 399 if (audioixp_chip_init(statep) != DDI_SUCCESS) { 400 audio_dev_warn(statep->adev, "DDI_RESUME failed to init chip"); 401 return (DDI_SUCCESS); 402 } 403 404 ac97_reset(statep->ac97); 405 audio_dev_resume(statep->adev); 406 407 return (DDI_SUCCESS); 408 } 409 410 /* 411 * audioixp_open() 412 * 413 * Description: 414 * Opens a DMA engine for use. 415 * 416 * Arguments: 417 * void *arg The DMA engine to set up 418 * int flag Open flags 419 * unsigned *nframesp Receives number of frames 420 * caddr_t *bufp Receives kernel data buffer 421 * 422 * Returns: 423 * 0 on success 424 * errno on failure 425 */ 426 static int 427 audioixp_open(void *arg, int flag, unsigned *nframesp, caddr_t *bufp) 428 { 429 audioixp_port_t *port = arg; 430 431 _NOTE(ARGUNUSED(flag)); 432 433 port->started = B_FALSE; 434 port->count = 0; 435 port->offset = 0; 436 *nframesp = port->nframes; 437 *bufp = port->samp_kaddr; 438 439 return (0); 440 } 441 442 /* 443 * audioixp_close() 444 * 445 * Description: 446 * Closes an audio DMA engine that was previously opened. Since 447 * nobody is using it, we take this opportunity to possibly power 448 * down the entire device. 449 * 450 * Arguments: 451 * void *arg The DMA engine to shut down 452 */ 453 static void 454 audioixp_close(void *arg) 455 { 456 _NOTE(ARGUNUSED(arg)); 457 } 458 459 /* 460 * audioixp_stop() 461 * 462 * Description: 463 * This is called by the framework to stop a port that is 464 * transferring data. 465 * 466 * Arguments: 467 * void *arg The DMA engine to stop 468 */ 469 static void 470 audioixp_stop(void *arg) 471 { 472 audioixp_port_t *port = arg; 473 audioixp_state_t *statep = port->statep; 474 475 mutex_enter(&statep->inst_lock); 476 if (port->num == IXP_REC) { 477 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN); 478 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN_DMA); 479 } else { 480 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT); 481 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT_DMA); 482 } 483 mutex_exit(&statep->inst_lock); 484 } 485 486 /* 487 * audioixp_start() 488 * 489 * Description: 490 * This is called by the framework to start a port transferring data. 491 * 492 * Arguments: 493 * void *arg The DMA engine to start 494 * 495 * Returns: 496 * 0 on success (never fails, errno if it did) 497 */ 498 static int 499 audioixp_start(void *arg) 500 { 501 audioixp_port_t *port = arg; 502 audioixp_state_t *statep = port->statep; 503 504 mutex_enter(&statep->inst_lock); 505 506 port->offset = 0; 507 508 if (port->num == IXP_REC) { 509 PUT32(IXP_AUDIO_FIFO_FLUSH, IXP_AUDIO_FIFO_FLUSH_IN); 510 SET32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_INTER_IN); 511 512 SET32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN_DMA); 513 PUT32(IXP_AUDIO_IN_DMA_LINK_P, 514 port->bdl_paddr | IXP_AUDIO_IN_DMA_LINK_P_EN); 515 516 SET32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN); 517 } else { 518 uint32_t slot = GET32(IXP_AUDIO_OUT_DMA_SLOT_EN_THRESHOLD); 519 PUT32(IXP_AUDIO_FIFO_FLUSH, IXP_AUDIO_FIFO_FLUSH_OUT); 520 /* clear all slots */ 521 slot &= ~ (IXP_AUDIO_OUT_DMA_SLOT_3 | 522 IXP_AUDIO_OUT_DMA_SLOT_4 | 523 IXP_AUDIO_OUT_DMA_SLOT_5 | 524 IXP_AUDIO_OUT_DMA_SLOT_6 | 525 IXP_AUDIO_OUT_DMA_SLOT_7 | 526 IXP_AUDIO_OUT_DMA_SLOT_8 | 527 IXP_AUDIO_OUT_DMA_SLOT_9 | 528 IXP_AUDIO_OUT_DMA_SLOT_10 | 529 IXP_AUDIO_OUT_DMA_SLOT_11 | 530 IXP_AUDIO_OUT_DMA_SLOT_12); 531 /* enable AC'97 output slots (depending on output channels) */ 532 slot |= IXP_AUDIO_OUT_DMA_SLOT_3 | 533 IXP_AUDIO_OUT_DMA_SLOT_4; 534 if (port->nchan >= 4) { 535 slot |= IXP_AUDIO_OUT_DMA_SLOT_6 | 536 IXP_AUDIO_OUT_DMA_SLOT_9; 537 } 538 if (port->nchan >= 6) { 539 slot |= IXP_AUDIO_OUT_DMA_SLOT_7 | 540 IXP_AUDIO_OUT_DMA_SLOT_8; 541 } 542 543 PUT32(IXP_AUDIO_OUT_DMA_SLOT_EN_THRESHOLD, slot); 544 545 SET32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_INTER_OUT); 546 547 SET32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT_DMA); 548 PUT32(IXP_AUDIO_OUT_DMA_LINK_P, 549 port->bdl_paddr | IXP_AUDIO_OUT_DMA_LINK_P_EN); 550 551 SET32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT); 552 } 553 mutex_exit(&statep->inst_lock); 554 return (0); 555 } 556 557 /* 558 * audioixp_format() 559 * 560 * Description: 561 * This is called by the framework to query the format for the device. 562 * 563 * Arguments: 564 * void *arg The DMA engine to query 565 * 566 * Returns: 567 * AUDIO_FORMAT_S16_LE 568 */ 569 static int 570 audioixp_format(void *arg) 571 { 572 _NOTE(ARGUNUSED(arg)); 573 574 return (AUDIO_FORMAT_S16_LE); 575 } 576 577 /* 578 * audioixp_channels() 579 * 580 * Description: 581 * This is called by the framework to query the channels for the device. 582 * 583 * Arguments: 584 * void *arg The DMA engine to query 585 * 586 * Returns: 587 * Number of channels for the device. 588 */ 589 static int 590 audioixp_channels(void *arg) 591 { 592 audioixp_port_t *port = arg; 593 594 return (port->nchan); 595 } 596 597 /* 598 * audioixp_rate() 599 * 600 * Description: 601 * This is called by the framework to query the rate of the device. 602 * 603 * Arguments: 604 * void *arg The DMA engine to query 605 * 606 * Returns: 607 * 48000 608 */ 609 static int 610 audioixp_rate(void *arg) 611 { 612 _NOTE(ARGUNUSED(arg)); 613 614 return (48000); 615 } 616 617 /* 618 * audioixp_count() 619 * 620 * Description: 621 * This is called by the framework to get the engine's frame counter 622 * 623 * Arguments: 624 * void *arg The DMA engine to query 625 * 626 * Returns: 627 * frame count for current engine 628 */ 629 static uint64_t 630 audioixp_count(void *arg) 631 { 632 audioixp_port_t *port = arg; 633 audioixp_state_t *statep = port->statep; 634 uint64_t val; 635 636 mutex_enter(&statep->inst_lock); 637 audioixp_update_port(port); 638 val = port->count; 639 mutex_exit(&statep->inst_lock); 640 641 return (val); 642 } 643 644 /* 645 * audioixp_sync() 646 * 647 * Description: 648 * This is called by the framework to synchronize DMA caches. 649 * 650 * Arguments: 651 * void *arg The DMA engine to sync 652 */ 653 static void 654 audioixp_sync(void *arg, unsigned nframes) 655 { 656 audioixp_port_t *port = arg; 657 _NOTE(ARGUNUSED(nframes)); 658 659 (void) ddi_dma_sync(port->samp_dmah, 0, 0, port->sync_dir); 660 } 661 662 /* *********************** Local Routines *************************** */ 663 664 /* 665 * audioixp_alloc_port() 666 * 667 * Description: 668 * This routine allocates the DMA handles and the memory for the 669 * DMA engines to use. It also configures the BDL lists properly 670 * for use. 671 * 672 * Arguments: 673 * dev_info_t *dip Pointer to the device's devinfo 674 * 675 * Returns: 676 * DDI_SUCCESS Registers successfully mapped 677 * DDI_FAILURE Registers not successfully mapped 678 */ 679 static int 680 audioixp_alloc_port(audioixp_state_t *statep, int num) 681 { 682 ddi_dma_cookie_t cookie; 683 uint_t count; 684 int dir; 685 unsigned caps; 686 audio_dev_t *adev; 687 audioixp_port_t *port; 688 uint32_t paddr; 689 int rc; 690 dev_info_t *dip; 691 audioixp_bd_entry_t *bdentry; 692 693 adev = statep->adev; 694 dip = statep->dip; 695 696 port = kmem_zalloc(sizeof (*port), KM_SLEEP); 697 port->statep = statep; 698 port->started = B_FALSE; 699 port->num = num; 700 701 switch (num) { 702 case IXP_REC: 703 statep->rec_port = port; 704 dir = DDI_DMA_READ; 705 caps = ENGINE_INPUT_CAP; 706 port->sync_dir = DDI_DMA_SYNC_FORKERNEL; 707 port->nchan = 2; 708 break; 709 case IXP_PLAY: 710 statep->play_port = port; 711 dir = DDI_DMA_WRITE; 712 caps = ENGINE_OUTPUT_CAP; 713 port->sync_dir = DDI_DMA_SYNC_FORDEV; 714 /* 715 * We allow for end users to configure more channels 716 * than just two, but we default to just two. The 717 * default stereo configuration works well. On the 718 * configurations we have tested, we've found that 719 * more than two channels (or rather 6 channels) can 720 * cause inexplicable noise. The noise is more 721 * noticeable when the system is running under load. 722 * (Holding the space bar in "top" while playing an 723 * MP3 is an easy way to recreate it.) End users who 724 * want to experiment, or have configurations that 725 * don't suffer from this, may increase the channels 726 * by setting this max-channels property. We leave it 727 * undocumented for now. 728 */ 729 port->nchan = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0, 730 "max-channels", 2); 731 port->nchan = min(ac97_num_channels(statep->ac97), 732 port->nchan); 733 port->nchan &= ~1; /* make sure its an even number */ 734 port->nchan = max(port->nchan, 2); 735 break; 736 default: 737 audio_dev_warn(adev, "bad port number (%d)!", num); 738 return (DDI_FAILURE); 739 } 740 741 port->nframes = 4096; 742 port->fragfr = port->nframes / IXP_BD_NUMS; 743 port->fragsz = port->fragfr * port->nchan * 2; 744 port->samp_size = port->nframes * port->nchan * 2; 745 746 /* allocate dma handle */ 747 rc = ddi_dma_alloc_handle(dip, &sample_buf_dma_attr, DDI_DMA_SLEEP, 748 NULL, &port->samp_dmah); 749 if (rc != DDI_SUCCESS) { 750 audio_dev_warn(adev, "ddi_dma_alloc_handle failed: %d", rc); 751 return (DDI_FAILURE); 752 } 753 /* allocate DMA buffer */ 754 rc = ddi_dma_mem_alloc(port->samp_dmah, port->samp_size, &buf_attr, 755 DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &port->samp_kaddr, 756 &port->samp_size, &port->samp_acch); 757 if (rc == DDI_FAILURE) { 758 audio_dev_warn(adev, "dma_mem_alloc failed"); 759 return (DDI_FAILURE); 760 } 761 762 /* bind DMA buffer */ 763 rc = ddi_dma_addr_bind_handle(port->samp_dmah, NULL, 764 port->samp_kaddr, port->samp_size, dir|DDI_DMA_CONSISTENT, 765 DDI_DMA_SLEEP, NULL, &cookie, &count); 766 if ((rc != DDI_DMA_MAPPED) || (count != 1)) { 767 audio_dev_warn(adev, 768 "ddi_dma_addr_bind_handle failed: %d", rc); 769 return (DDI_FAILURE); 770 } 771 port->samp_paddr = cookie.dmac_address; 772 773 /* 774 * now, from here we allocate DMA memory for buffer descriptor list. 775 * we allocate adjacent DMA memory for all DMA engines. 776 */ 777 rc = ddi_dma_alloc_handle(dip, &bdlist_dma_attr, DDI_DMA_SLEEP, 778 NULL, &port->bdl_dmah); 779 if (rc != DDI_SUCCESS) { 780 audio_dev_warn(adev, "ddi_dma_alloc_handle(bdlist) failed"); 781 return (DDI_FAILURE); 782 } 783 784 /* 785 * we allocate all buffer descriptors lists in continuous dma memory. 786 */ 787 port->bdl_size = sizeof (audioixp_bd_entry_t) * IXP_BD_NUMS; 788 rc = ddi_dma_mem_alloc(port->bdl_dmah, port->bdl_size, 789 &dev_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, 790 &port->bdl_kaddr, &port->bdl_size, &port->bdl_acch); 791 if (rc != DDI_SUCCESS) { 792 audio_dev_warn(adev, "ddi_dma_mem_alloc(bdlist) failed"); 793 return (DDI_FAILURE); 794 } 795 796 rc = ddi_dma_addr_bind_handle(port->bdl_dmah, NULL, port->bdl_kaddr, 797 port->bdl_size, DDI_DMA_WRITE|DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, 798 NULL, &cookie, &count); 799 if ((rc != DDI_DMA_MAPPED) || (count != 1)) { 800 audio_dev_warn(adev, "addr_bind_handle failed"); 801 return (DDI_FAILURE); 802 } 803 port->bdl_paddr = cookie.dmac_address; 804 805 /* 806 * Wire up the BD list. 807 */ 808 paddr = port->samp_paddr; 809 bdentry = (void *)port->bdl_kaddr; 810 811 for (int i = 0; i < IXP_BD_NUMS; i++) { 812 813 /* set base address of buffer */ 814 ddi_put32(port->bdl_acch, &bdentry->buf_base, paddr); 815 ddi_put16(port->bdl_acch, &bdentry->status, 0); 816 ddi_put16(port->bdl_acch, &bdentry->buf_len, port->fragsz / 4); 817 ddi_put32(port->bdl_acch, &bdentry->next, port->bdl_paddr + 818 (((i + 1) % IXP_BD_NUMS) * sizeof (audioixp_bd_entry_t))); 819 paddr += port->fragsz; 820 bdentry++; 821 } 822 (void) ddi_dma_sync(port->bdl_dmah, 0, 0, DDI_DMA_SYNC_FORDEV); 823 824 port->engine = audio_engine_alloc(&audioixp_engine_ops, caps); 825 if (port->engine == NULL) { 826 audio_dev_warn(adev, "audio_engine_alloc failed"); 827 return (DDI_FAILURE); 828 } 829 830 audio_engine_set_private(port->engine, port); 831 audio_dev_add_engine(adev, port->engine); 832 833 return (DDI_SUCCESS); 834 } 835 836 /* 837 * audioixp_free_port() 838 * 839 * Description: 840 * This routine unbinds the DMA cookies, frees the DMA buffers, 841 * deallocates the DMA handles. 842 * 843 * Arguments: 844 * audioixp_port_t *port The port structure for a DMA engine. 845 */ 846 static void 847 audioixp_free_port(audioixp_port_t *port) 848 { 849 if (port == NULL) 850 return; 851 852 if (port->engine) { 853 audio_dev_remove_engine(port->statep->adev, port->engine); 854 audio_engine_free(port->engine); 855 } 856 if (port->bdl_paddr) { 857 (void) ddi_dma_unbind_handle(port->bdl_dmah); 858 } 859 if (port->bdl_acch) { 860 ddi_dma_mem_free(&port->bdl_acch); 861 } 862 if (port->bdl_dmah) { 863 ddi_dma_free_handle(&port->bdl_dmah); 864 } 865 if (port->samp_paddr) { 866 (void) ddi_dma_unbind_handle(port->samp_dmah); 867 } 868 if (port->samp_acch) { 869 ddi_dma_mem_free(&port->samp_acch); 870 } 871 if (port->samp_dmah) { 872 ddi_dma_free_handle(&port->samp_dmah); 873 } 874 kmem_free(port, sizeof (*port)); 875 } 876 877 /* 878 * audioixp_update_port() 879 * 880 * Description: 881 * This routine updates the ports frame counter from hardware, and 882 * gracefully handles wraps. 883 * 884 * Arguments: 885 * audioixp_port_t *port The port to update. 886 */ 887 static void 888 audioixp_update_port(audioixp_port_t *port) 889 { 890 audioixp_state_t *statep = port->statep; 891 unsigned regoff; 892 unsigned n; 893 int loop; 894 uint32_t offset; 895 uint32_t paddr; 896 897 if (port->num == IXP_REC) { 898 regoff = IXP_AUDIO_IN_DMA_DT_CUR; 899 } else { 900 regoff = IXP_AUDIO_OUT_DMA_DT_CUR; 901 } 902 903 /* 904 * Apparently it may take several tries to get an update on the 905 * position. Is this a hardware bug? 906 */ 907 for (loop = 100; loop; loop--) { 908 paddr = GET32(regoff); 909 910 /* make sure address is reasonable */ 911 if ((paddr < port->samp_paddr) || 912 (paddr >= (port->samp_paddr + port->samp_size))) { 913 continue; 914 } 915 916 offset = paddr - port->samp_paddr; 917 918 if (offset >= port->offset) { 919 n = offset - port->offset; 920 } else { 921 n = offset + (port->samp_size - port->offset); 922 } 923 port->offset = offset; 924 port->count += (n / (port->nchan * sizeof (uint16_t))); 925 return; 926 } 927 928 audio_dev_warn(statep->adev, "Unable to update count (h/w bug?)"); 929 } 930 931 932 /* 933 * audioixp_map_regs() 934 * 935 * Description: 936 * The registers are mapped in. 937 * 938 * Arguments: 939 * audioixp_state_t *state The device's state structure 940 * 941 * Returns: 942 * DDI_SUCCESS Registers successfully mapped 943 * DDI_FAILURE Registers not successfully mapped 944 */ 945 static int 946 audioixp_map_regs(audioixp_state_t *statep) 947 { 948 dev_info_t *dip = statep->dip; 949 950 /* map PCI config space */ 951 if (pci_config_setup(statep->dip, &statep->pcih) == DDI_FAILURE) { 952 audio_dev_warn(statep->adev, "unable to map PCI config space"); 953 return (DDI_FAILURE); 954 } 955 956 /* map audio mixer register */ 957 if ((ddi_regs_map_setup(dip, IXP_IO_AM_REGS, &statep->regsp, 0, 0, 958 &dev_attr, &statep->regsh)) != DDI_SUCCESS) { 959 audio_dev_warn(statep->adev, "unable to map audio registers"); 960 return (DDI_FAILURE); 961 } 962 return (DDI_SUCCESS); 963 } 964 965 /* 966 * audioixp_unmap_regs() 967 * 968 * Description: 969 * This routine unmaps control registers. 970 * 971 * Arguments: 972 * audioixp_state_t *state The device's state structure 973 */ 974 static void 975 audioixp_unmap_regs(audioixp_state_t *statep) 976 { 977 if (statep->regsh) { 978 ddi_regs_map_free(&statep->regsh); 979 } 980 981 if (statep->pcih) { 982 pci_config_teardown(&statep->pcih); 983 } 984 } 985 986 /* 987 * audioixp_codec_ready() 988 * 989 * Description: 990 * This routine checks the state of codecs. It checks the flag to confirm 991 * that primary codec is ready. 992 * 993 * Arguments: 994 * audioixp_state_t *state The device's state structure 995 * 996 * Returns: 997 * DDI_SUCCESS codec is ready 998 * DDI_FAILURE codec is not ready 999 */ 1000 static int 1001 audioixp_codec_ready(audioixp_state_t *statep) 1002 { 1003 uint32_t sr; 1004 1005 PUT32(IXP_AUDIO_INT, 0xffffffff); 1006 drv_usecwait(1000); 1007 1008 sr = GET32(IXP_AUDIO_INT); 1009 if (sr & IXP_AUDIO_INT_CODEC0_NOT_READY) { 1010 PUT32(IXP_AUDIO_INT, IXP_AUDIO_INT_CODEC0_NOT_READY); 1011 audio_dev_warn(statep->adev, "primary codec not ready"); 1012 1013 return (DDI_FAILURE); 1014 } 1015 return (DDI_SUCCESS); 1016 } 1017 1018 /* 1019 * audioixp_codec_sync() 1020 * 1021 * Description: 1022 * Serialize access to the AC97 audio mixer registers. 1023 * 1024 * Arguments: 1025 * audioixp_state_t *state The device's state structure 1026 * 1027 * Returns: 1028 * DDI_SUCCESS Ready for an I/O access to the codec 1029 * DDI_FAILURE An I/O access is currently in progress, can't 1030 * perform another I/O access. 1031 */ 1032 static int 1033 audioixp_codec_sync(audioixp_state_t *statep) 1034 { 1035 int i; 1036 uint32_t cmd; 1037 1038 for (i = 0; i < 300; i++) { 1039 cmd = GET32(IXP_AUDIO_OUT_PHY_ADDR_DATA); 1040 if (!(cmd & IXP_AUDIO_OUT_PHY_EN)) { 1041 return (DDI_SUCCESS); 1042 } 1043 drv_usecwait(10); 1044 } 1045 1046 audio_dev_warn(statep->adev, "unable to synchronize codec"); 1047 return (DDI_FAILURE); 1048 } 1049 1050 /* 1051 * audioixp_rd97() 1052 * 1053 * Description: 1054 * Get the specific AC97 Codec register. 1055 * 1056 * Arguments: 1057 * void *arg The device's state structure 1058 * uint8_t reg AC97 register number 1059 * 1060 * Returns: 1061 * Register value. 1062 */ 1063 static uint16_t 1064 audioixp_rd97(void *arg, uint8_t reg) 1065 { 1066 audioixp_state_t *statep = arg; 1067 uint32_t value; 1068 uint32_t result; 1069 1070 if (audioixp_codec_sync(statep) != DDI_SUCCESS) 1071 return (0xffff); 1072 1073 value = IXP_AUDIO_OUT_PHY_PRIMARY_CODEC | 1074 IXP_AUDIO_OUT_PHY_READ | 1075 IXP_AUDIO_OUT_PHY_EN | 1076 ((unsigned)reg << IXP_AUDIO_OUT_PHY_ADDR_SHIFT); 1077 PUT32(IXP_AUDIO_OUT_PHY_ADDR_DATA, value); 1078 1079 if (audioixp_codec_sync(statep) != DDI_SUCCESS) 1080 return (0xffff); 1081 1082 for (int i = 0; i < 300; i++) { 1083 result = GET32(IXP_AUDIO_IN_PHY_ADDR_DATA); 1084 if (result & IXP_AUDIO_IN_PHY_READY) { 1085 return (result >> IXP_AUDIO_IN_PHY_DATA_SHIFT); 1086 } 1087 drv_usecwait(10); 1088 } 1089 1090 done: 1091 audio_dev_warn(statep->adev, "time out reading codec reg %d", reg); 1092 return (0xffff); 1093 } 1094 1095 /* 1096 * audioixp_wr97() 1097 * 1098 * Description: 1099 * Set the specific AC97 Codec register. 1100 * 1101 * Arguments: 1102 * void *arg The device's state structure 1103 * uint8_t reg AC97 register number 1104 * uint16_t data The data want to be set 1105 */ 1106 static void 1107 audioixp_wr97(void *arg, uint8_t reg, uint16_t data) 1108 { 1109 audioixp_state_t *statep = arg; 1110 uint32_t value; 1111 1112 if (audioixp_codec_sync(statep) != DDI_SUCCESS) { 1113 return; 1114 } 1115 1116 value = IXP_AUDIO_OUT_PHY_PRIMARY_CODEC | 1117 IXP_AUDIO_OUT_PHY_WRITE | 1118 IXP_AUDIO_OUT_PHY_EN | 1119 ((unsigned)reg << IXP_AUDIO_OUT_PHY_ADDR_SHIFT) | 1120 ((unsigned)data << IXP_AUDIO_OUT_PHY_DATA_SHIFT); 1121 PUT32(IXP_AUDIO_OUT_PHY_ADDR_DATA, value); 1122 1123 (void) audioixp_rd97(statep, reg); 1124 } 1125 1126 /* 1127 * audioixp_reset_ac97() 1128 * 1129 * Description: 1130 * Reset AC97 Codec register. 1131 * 1132 * Arguments: 1133 * audioixp_state_t *state The device's state structure 1134 * 1135 * Returns: 1136 * DDI_SUCCESS Reset the codec successfully 1137 * DDI_FAILURE Failed to reset the codec 1138 */ 1139 static int 1140 audioixp_reset_ac97(audioixp_state_t *statep) 1141 { 1142 uint32_t cmd; 1143 int i; 1144 1145 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_POWER_DOWN); 1146 drv_usecwait(10); 1147 1148 /* register reset */ 1149 SET32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_AC_SOFT_RESET); 1150 /* force a read to flush caches */ 1151 (void) GET32(IXP_AUDIO_CMD); 1152 1153 drv_usecwait(10); 1154 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_AC_SOFT_RESET); 1155 1156 /* cold reset */ 1157 for (i = 0; i < 300; i++) { 1158 cmd = GET32(IXP_AUDIO_CMD); 1159 if (cmd & IXP_AUDIO_CMD_AC_ACTIVE) { 1160 cmd |= IXP_AUDIO_CMD_AC_RESET | IXP_AUDIO_CMD_AC_SYNC; 1161 PUT32(IXP_AUDIO_CMD, cmd); 1162 return (DDI_SUCCESS); 1163 } 1164 cmd &= ~IXP_AUDIO_CMD_AC_RESET; 1165 cmd |= IXP_AUDIO_CMD_AC_SYNC; 1166 PUT32(IXP_AUDIO_CMD, cmd); 1167 (void) GET32(IXP_AUDIO_CMD); 1168 drv_usecwait(10); 1169 cmd |= IXP_AUDIO_CMD_AC_RESET; 1170 PUT32(IXP_AUDIO_CMD, cmd); 1171 drv_usecwait(10); 1172 } 1173 1174 audio_dev_warn(statep->adev, "AC'97 reset timed out"); 1175 return (DDI_FAILURE); 1176 } 1177 1178 /* 1179 * audioixp_chip_init() 1180 * 1181 * Description: 1182 * This routine initializes ATI IXP audio controller and the AC97 1183 * codec. 1184 * 1185 * Arguments: 1186 * audioixp_state_t *state The device's state structure 1187 * 1188 * Returns: 1189 * DDI_SUCCESS The hardware was initialized properly 1190 * DDI_FAILURE The hardware couldn't be initialized properly 1191 */ 1192 static int 1193 audioixp_chip_init(audioixp_state_t *statep) 1194 { 1195 /* 1196 * put the audio controller into quiet state, everything off 1197 */ 1198 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT_DMA); 1199 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN_DMA); 1200 1201 /* AC97 reset */ 1202 if (audioixp_reset_ac97(statep) != DDI_SUCCESS) { 1203 audio_dev_warn(statep->adev, "AC97 codec reset failed"); 1204 return (DDI_FAILURE); 1205 } 1206 1207 if (audioixp_codec_ready(statep) != DDI_SUCCESS) { 1208 audio_dev_warn(statep->adev, "AC97 codec not ready"); 1209 return (DDI_FAILURE); 1210 } 1211 1212 return (DDI_SUCCESS); 1213 1214 } /* audioixp_chip_init() */ 1215 1216 /* 1217 * audioixp_attach() 1218 * 1219 * Description: 1220 * Attach an instance of the audioixp driver. This routine does 1221 * the device dependent attach tasks. 1222 * 1223 * Arguments: 1224 * dev_info_t *dip Pointer to the device's dev_info struct 1225 * ddi_attach_cmd_t cmd Attach command 1226 * 1227 * Returns: 1228 * DDI_SUCCESS The driver was initialized properly 1229 * DDI_FAILURE The driver couldn't be initialized properly 1230 */ 1231 static int 1232 audioixp_attach(dev_info_t *dip) 1233 { 1234 uint16_t cmdeg; 1235 audioixp_state_t *statep; 1236 audio_dev_t *adev; 1237 uint32_t devid; 1238 const char *name; 1239 const char *rev; 1240 1241 /* allocate the soft state structure */ 1242 statep = kmem_zalloc(sizeof (*statep), KM_SLEEP); 1243 statep->dip = dip; 1244 ddi_set_driver_private(dip, statep); 1245 mutex_init(&statep->inst_lock, NULL, MUTEX_DRIVER, NULL); 1246 1247 /* allocate framework audio device */ 1248 if ((adev = audio_dev_alloc(dip, 0)) == NULL) { 1249 cmn_err(CE_WARN, "!%s%d: unable to allocate audio dev", 1250 ddi_driver_name(dip), ddi_get_instance(dip)); 1251 goto error; 1252 } 1253 statep->adev = adev; 1254 1255 /* map in the registers */ 1256 if (audioixp_map_regs(statep) != DDI_SUCCESS) { 1257 audio_dev_warn(adev, "couldn't map registers"); 1258 goto error; 1259 } 1260 1261 /* set device information -- this could be smarter */ 1262 devid = ((pci_config_get16(statep->pcih, PCI_CONF_VENID)) << 16) | 1263 pci_config_get16(statep->pcih, PCI_CONF_DEVID); 1264 1265 name = "ATI AC'97"; 1266 switch (devid) { 1267 case IXP_PCI_ID_200: 1268 rev = "IXP150"; 1269 break; 1270 case IXP_PCI_ID_300: 1271 rev = "SB300"; 1272 break; 1273 case IXP_PCI_ID_400: 1274 if (pci_config_get8(statep->pcih, PCI_CONF_REVID) & 0x80) { 1275 rev = "SB450"; 1276 } else { 1277 rev = "SB400"; 1278 } 1279 break; 1280 case IXP_PCI_ID_SB600: 1281 rev = "SB600"; 1282 break; 1283 default: 1284 rev = "Unknown"; 1285 break; 1286 } 1287 audio_dev_set_description(adev, name); 1288 audio_dev_set_version(adev, rev); 1289 1290 /* set PCI command register */ 1291 cmdeg = pci_config_get16(statep->pcih, PCI_CONF_COMM); 1292 pci_config_put16(statep->pcih, PCI_CONF_COMM, 1293 cmdeg | PCI_COMM_IO | PCI_COMM_MAE); 1294 1295 statep->ac97 = ac97_alloc(dip, audioixp_rd97, audioixp_wr97, statep); 1296 if (statep->ac97 == NULL) { 1297 audio_dev_warn(adev, "failed to allocate ac97 handle"); 1298 goto error; 1299 } 1300 1301 /* allocate port structures */ 1302 if ((audioixp_alloc_port(statep, IXP_PLAY) != DDI_SUCCESS) || 1303 (audioixp_alloc_port(statep, IXP_REC) != DDI_SUCCESS)) { 1304 goto error; 1305 } 1306 1307 /* 1308 * If we have locked in a stereo configuration, then don't expose 1309 * multichannel-specific AC'97 codec controls. 1310 */ 1311 if (statep->play_port->nchan == 2) { 1312 int i; 1313 ac97_ctrl_t *ctrl; 1314 const char *name; 1315 1316 for (i = 0; (name = audioixp_remove_ac97[i]) != NULL; i++) { 1317 ctrl = ac97_control_find(statep->ac97, name); 1318 if (ctrl != NULL) { 1319 ac97_control_unregister(ctrl); 1320 } 1321 } 1322 } 1323 1324 if (audioixp_chip_init(statep) != DDI_SUCCESS) { 1325 audio_dev_warn(statep->adev, "failed to init chip"); 1326 goto error; 1327 } 1328 1329 /* initialize the AC'97 part */ 1330 if (ac97_init(statep->ac97, adev) != DDI_SUCCESS) { 1331 audio_dev_warn(adev, "ac'97 initialization failed"); 1332 goto error; 1333 } 1334 1335 if (audio_dev_register(adev) != DDI_SUCCESS) { 1336 audio_dev_warn(adev, "unable to register with framework"); 1337 goto error; 1338 } 1339 1340 ddi_report_dev(dip); 1341 1342 return (DDI_SUCCESS); 1343 1344 error: 1345 audioixp_destroy(statep); 1346 return (DDI_FAILURE); 1347 } 1348 1349 /* 1350 * audioixp_detach() 1351 * 1352 * Description: 1353 * Detach an instance of the audioixp driver. 1354 * 1355 * Arguments: 1356 * dev_info_t *dip Pointer to the device's dev_info struct 1357 * 1358 * Returns: 1359 * DDI_SUCCESS The driver was detached 1360 * DDI_FAILURE The driver couldn't be detached 1361 */ 1362 static int 1363 audioixp_detach(dev_info_t *dip) 1364 { 1365 audioixp_state_t *statep; 1366 1367 statep = ddi_get_driver_private(dip); 1368 1369 if (audio_dev_unregister(statep->adev) != DDI_SUCCESS) { 1370 return (DDI_FAILURE); 1371 } 1372 1373 audioixp_destroy(statep); 1374 return (DDI_SUCCESS); 1375 } 1376 1377 /* 1378 * audioixp_destroy() 1379 * 1380 * Description: 1381 * This routine releases all resources held by the device instance, 1382 * as part of either detach or a failure in attach. 1383 * 1384 * Arguments: 1385 * audioixp_state_t *state The device soft state. 1386 */ 1387 static void 1388 audioixp_destroy(audioixp_state_t *statep) 1389 { 1390 /* 1391 * put the audio controller into quiet state, everything off 1392 */ 1393 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_OUT_DMA); 1394 CLR32(IXP_AUDIO_CMD, IXP_AUDIO_CMD_EN_IN_DMA); 1395 1396 audioixp_free_port(statep->play_port); 1397 audioixp_free_port(statep->rec_port); 1398 1399 audioixp_unmap_regs(statep); 1400 1401 if (statep->ac97) { 1402 ac97_free(statep->ac97); 1403 } 1404 1405 if (statep->adev) { 1406 audio_dev_free(statep->adev); 1407 } 1408 1409 mutex_destroy(&statep->inst_lock); 1410 kmem_free(statep, sizeof (*statep)); 1411 }