/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * audio1575 Audio Driver * * The driver is primarily targeted at providing audio support for * those systems which use the Uli M1575 audio core. * * The M1575 audio core, in AC'97 controller mode, has independent * channels for PCM in, PCM out, mic in, modem in, and modem out. * * The AC'97 controller is a PCI bus master with scatter/gather * support. Each channel has a DMA engine. Currently, we use only * the PCM in and PCM out channels. Each DMA engine uses one buffer * descriptor list. And the buffer descriptor list is an array of up * to 32 entries, each of which describes a data buffer. Each entry * contains a pointer to a data buffer, control bits, and the length * of the buffer being pointed to, where the length is expressed as * the number of samples. This, combined with the 16-bit sample size, * gives the actual physical length of the buffer. * * NOTE: * This driver depends on the drv/audio, misc/ac97 * modules being loaded first. */ #include #include #include #include #include #include #include #include #include #include #include "audio1575.h" /* * Module linkage routines for the kernel */ static int audio1575_ddi_attach(dev_info_t *, ddi_attach_cmd_t); static int audio1575_ddi_detach(dev_info_t *, ddi_detach_cmd_t); static int audio1575_ddi_quiesce(dev_info_t *); /* * Entry point routine prototypes */ static int audio1575_open(void *, int, unsigned *, caddr_t *); static void audio1575_close(void *); static int audio1575_start(void *); static void audio1575_stop(void *); static int audio1575_format(void *); static int audio1575_channels(void *); static int audio1575_rate(void *); static uint64_t audio1575_count(void *); static void audio1575_sync(void *, unsigned); static audio_engine_ops_t audio1575_engine_ops = { AUDIO_ENGINE_VERSION, audio1575_open, audio1575_close, audio1575_start, audio1575_stop, audio1575_count, audio1575_format, audio1575_channels, audio1575_rate, audio1575_sync, NULL, NULL, NULL }; /* * Local Routine Prototypes */ static int audio1575_attach(dev_info_t *); static int audio1575_resume(dev_info_t *); static int audio1575_detach(dev_info_t *); static int audio1575_suspend(dev_info_t *); static int audio1575_alloc_port(audio1575_state_t *, int, uint8_t); static void audio1575_free_port(audio1575_port_t *); static int audio1575_codec_sync(audio1575_state_t *); static void audio1575_write_ac97(void *, uint8_t, uint16_t); static uint16_t audio1575_read_ac97(void *, uint8_t); static int audio1575_chip_init(audio1575_state_t *); static int audio1575_map_regs(audio1575_state_t *); static void audio1575_unmap_regs(audio1575_state_t *); static void audio1575_dma_stop(audio1575_state_t *, boolean_t); static void audio1575_pci_enable(audio1575_state_t *); static void audio1575_pci_disable(audio1575_state_t *); static void audio1575_destroy(audio1575_state_t *); /* * Global variables, but used only by this file. */ /* * DDI Structures */ /* Device operations structure */ static struct dev_ops audio1575_dev_ops = { DEVO_REV, /* devo_rev */ 0, /* devo_refcnt */ NULL, /* devo_getinfo */ nulldev, /* devo_identify - obsolete */ nulldev, /* devo_probe */ audio1575_ddi_attach, /* devo_attach */ audio1575_ddi_detach, /* devo_detach */ nodev, /* devo_reset */ NULL, /* devi_cb_ops */ NULL, /* devo_bus_ops */ NULL, /* devo_power */ audio1575_ddi_quiesce, /* devo_quiesce */ }; /* Linkage structure for loadable drivers */ static struct modldrv audio1575_modldrv = { &mod_driverops, /* drv_modops */ M1575_MOD_NAME, /* drv_linkinfo */ &audio1575_dev_ops, /* drv_dev_ops */ }; /* Module linkage structure */ static struct modlinkage audio1575_modlinkage = { MODREV_1, /* ml_rev */ (void *)&audio1575_modldrv, /* ml_linkage */ NULL /* NULL terminates the list */ }; /* * device access attributes for register mapping */ static struct ddi_device_acc_attr dev_attr = { DDI_DEVICE_ATTR_V0, DDI_STRUCTURE_LE_ACC, DDI_STRICTORDER_ACC }; static struct ddi_device_acc_attr buf_attr = { DDI_DEVICE_ATTR_V0, DDI_NEVERSWAP_ACC, DDI_STRICTORDER_ACC }; /* * DMA attributes of buffer descriptor list */ static ddi_dma_attr_t bdlist_dma_attr = { DMA_ATTR_V0, /* version */ 0x0000000000000000LL, /* dlim_addr_lo */ 0x00000000ffffffffLL, /* dlim_addr_hi */ 0x000000000000ffffLL, /* DMA counter register - 64 bits */ 0x0000000000000008LL, /* DMA address align must be 8-bytes */ 0x0000003c, /* 1 through 64 byte burst sizes */ 0x00000008, /* min xfer DMA size BDList entry */ 0x00000000000ffffLL, /* max xfer size, 64K */ 0x000000000001fffLL, /* seg, set to PAGESIZE */ 0x00000001, /* s/g list length, no s/g */ 0x00000008, /* granularity of device minxfer */ 0 /* DMA flags use virtual address */ }; /* * DMA attributes of buffers to be used to receive/send audio data */ static ddi_dma_attr_t sample_buf_dma_attr = { DMA_ATTR_V0, 0x0000000000000000LL, /* dlim_addr_lo */ 0x00000000ffffffffLL, /* dlim_addr_hi */ 0x000000000001fffeLL, /* DMA counter register - 16 bits */ 0x0000000000000004LL, /* DMA address align 2-byte boundary */ 0x0000003c, /* 1 through 60 byte burst sizes */ 0x00000004, /* min xfer DMA size BDList entry */ 0x000000000001ffffLL, /* max xfer size, 64K */ 0x000000000001ffffLL, /* seg, set to 64K */ 0x00000001, /* s/g list length, no s/g */ 0x00000004, /* granularity of device minxfer */ 0 /* DMA flags use virtual address */ }; /* * _init() * * Description: * Driver initialization, called when driver is first loaded. * This is how access is initially given to all the static structures. * * Arguments: * None * * Returns: * mod_install() status, see mod_install(9f) */ int _init(void) { int error; audio_init_ops(&audio1575_dev_ops, M1575_NAME); if ((error = mod_install(&audio1575_modlinkage)) != 0) { audio_fini_ops(&audio1575_dev_ops); } return (error); } /* * _fini() * * Description: * Module de-initialization, called when the driver is to be unloaded. * * Arguments: * None * * Returns: * mod_remove() status, see mod_remove(9f) */ int _fini(void) { int error; if ((error = mod_remove(&audio1575_modlinkage)) != 0) { return (error); } /* clean up ops */ audio_fini_ops(&audio1575_dev_ops); return (0); } /* * _info() * * Description: * Module information, returns information about the driver. * * Arguments: * modinfo *modinfop Pointer to the opaque modinfo structure * * Returns: * mod_info() status, see mod_info(9f) */ int _info(struct modinfo *modinfop) { return (mod_info(&audio1575_modlinkage, modinfop)); } /* ******************* Driver Entry Points ********************************* */ /* * audio1575_ddi_attach() * * Description: * Implements the DDI attach(9e) entry point. * * Arguments: * dev_info_t *dip Pointer to the device's dev_info struct * ddi_attach_cmd_t cmd Attach command * * Returns: * DDI_SUCCESS The driver was initialized properly * DDI_FAILURE The driver couldn't be initialized properly */ static int audio1575_ddi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) { switch (cmd) { case DDI_ATTACH: return (audio1575_attach(dip)); case DDI_RESUME: return (audio1575_resume(dip)); } return (DDI_FAILURE); } /* * audio1575_ddi_detach() * * Description: * Implements the detach(9e) entry point. * * Arguments: * dev_info_t *dip Pointer to the device's dev_info struct * ddi_detach_cmd_t cmd Detach command * * Returns: * DDI_SUCCESS The driver was detached * DDI_FAILURE The driver couldn't be detached */ static int audio1575_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) { switch (cmd) { case DDI_DETACH: return (audio1575_detach(dip)); case DDI_SUSPEND: return (audio1575_suspend(dip)); } return (DDI_FAILURE); } /* * audio1575_ddi_quiesce() * * Description: * Implements the quiesce(9e) entry point. * * Arguments: * dev_info_t *dip Pointer to the device's dev_info struct * * Returns: * DDI_SUCCESS The driver was quiesced * DDI_FAILURE The driver couldn't be quiesced */ static int audio1575_ddi_quiesce(dev_info_t *dip) { audio1575_state_t *statep; if ((statep = ddi_get_driver_private(dip)) == NULL) return (DDI_FAILURE); audio1575_dma_stop(statep, B_TRUE); return (DDI_SUCCESS); } /* * audio1575_open() * * Description: * Opens a DMA engine for use. * * Arguments: * void *arg The DMA engine to set up * int flag Open flags * unsigned *nframesp Receives number of frames * caddr_t *bufp Receives kernel data buffer * * Returns: * 0 on success * errno on failure */ static int audio1575_open(void *arg, int flag, unsigned *nframesp, caddr_t *bufp) { audio1575_port_t *port = arg; _NOTE(ARGUNUSED(flag)); port->count = 0; *nframesp = port->nframes; *bufp = port->samp_kaddr; return (0); } /* * audio1575_close() * * Description: * Closes an audio DMA engine that was previously opened. Since * nobody is using it, we take this opportunity to possibly power * down the entire device. * * Arguments: * void *arg The DMA engine to shut down */ static void audio1575_close(void *arg) { _NOTE(ARGUNUSED(arg)); } /* * audio1575_stop() * * Description: * This is called by the framework to stop a port that is * transferring data. * * Arguments: * void *arg The DMA engine to stop */ static void audio1575_stop(void *arg) { audio1575_port_t *port = arg; audio1575_state_t *statep = port->statep; mutex_enter(&statep->lock); if (port->num == M1575_REC) { SET32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE); } else { SET32(M1575_DMACR_REG, M1575_DMACR_PCMOPAUSE); } mutex_exit(&statep->lock); } /* * audio1575_start() * * Description: * This is called by the framework to start a port transferring data. * * Arguments: * void *arg The DMA engine to start * * Returns: * 0 on success (never fails, errno if it did) */ static int audio1575_start(void *arg) { audio1575_port_t *port = arg; audio1575_state_t *statep = port->statep; mutex_enter(&statep->lock); port->offset = 0; if (port->num == M1575_REC) { /* Uli FIFO madness ... */ SET32(M1575_FIFOCR1_REG, M1575_FIFOCR1_PCMIRST); SET32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE); PUT8(M1575_PCMICR_REG, 0); PUT8(M1575_PCMICR_REG, M1575_CR_RR); PUT32(M1575_PCMIBDBAR_REG, port->bdl_paddr); PUT8(M1575_PCMILVIV_REG, M1575_BD_NUMS - 1); CLR32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE); /* ULi says do fifo resets here */ SET32(M1575_FIFOCR1_REG, M1575_FIFOCR1_PCMIRST); CLR32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE); PUT8(M1575_PCMICR_REG, 0); SET32(M1575_DMACR_REG, M1575_DMACR_PCMISTART); } else { uint32_t scr; /* Uli FIFO madness ... */ SET32(M1575_FIFOCR1_REG, M1575_FIFOCR1_PCMORST); SET32(M1575_DMACR_REG, M1575_DMACR_PCMOPAUSE); /* configure the number of channels properly */ scr = GET32(M1575_SCR_REG); scr &= ~(M1575_SCR_6CHL_MASK | M1575_SCR_CHAMOD_MASK); scr |= M1575_SCR_6CHL_2; /* select our proper ordering */ switch (port->nchan) { case 2: scr |= M1575_SCR_CHAMOD_2; break; case 4: scr |= M1575_SCR_CHAMOD_4; break; case 6: scr |= M1575_SCR_CHAMOD_6; break; } PUT32(M1575_SCR_REG, scr); PUT8(M1575_PCMOCR_REG, 0); PUT8(M1575_PCMOCR_REG, M1575_CR_RR); PUT32(M1575_PCMOBDBAR_REG, port->bdl_paddr); PUT8(M1575_PCMOLVIV_REG, M1575_BD_NUMS - 1); CLR32(M1575_DMACR_REG, M1575_DMACR_PCMOPAUSE); PUT8(M1575_PCMOCR_REG, 0); SET32(M1575_DMACR_REG, M1575_DMACR_PCMOSTART); } mutex_exit(&statep->lock); return (0); } /* * audio1575_format() * * Description: * Called by the framework to query the format for the device. * * Arguments: * void *arg The DMA engine to query * * Returns: * AUDIO_FORMAT_S16_LE */ static int audio1575_format(void *arg) { _NOTE(ARGUNUSED(arg)); return (AUDIO_FORMAT_S16_LE); } /* * audio1575_channels() * * Description: * Called by the framework to query the channels for the device. * * Arguments: * void *arg The DMA engine to query * * Returns: * Number of channels for the device */ static int audio1575_channels(void *arg) { audio1575_port_t *port = arg; return (port->nchan); } /* * audio1575_rate() * * Description: * Called by the framework to query the sample rate for the device. * * Arguments: * void *arg The DMA engine to query * * Returns: * 48000 */ static int audio1575_rate(void *arg) { _NOTE(ARGUNUSED(arg)); return (48000); } /* * audio1575_count() * * Description: * This is called by the framework to get the engine's frame counter * * Arguments: * void *arg The DMA engine to query * * Returns: * frame count for current engine */ static uint64_t audio1575_count(void *arg) { audio1575_port_t *port = arg; audio1575_state_t *statep = port->statep; uint64_t val; uint8_t civ; unsigned n; int civoff; int lvioff; int picoff; mutex_enter(&statep->lock); if (port->num == M1575_REC) { civoff = M1575_PCMICIV_REG; lvioff = M1575_PCMILVIV_REG; picoff = M1575_PCMIPICB_REG; } else { civoff = M1575_PCMOCIV_REG; lvioff = M1575_PCMOLVIV_REG; picoff = M1575_PCMOPICB_REG; } /* * Read the position counters. We also take this opportunity * to update the last valid index to the one just previous to * the one we're working on (so we'll fully loop.) */ n = GET16(picoff); civ = GET8(civoff); PUT8(lvioff, (civ - 1) % M1575_BD_NUMS); n = port->samp_size - (n * sizeof (int16_t)); if (n < port->offset) { val = (port->samp_size - port->offset) + n; } else { val = n - port->offset; } port->offset = n; port->count += (val / (port->nchan * sizeof (int16_t))); val = port->count; mutex_exit(&statep->lock); return (val); } /* * audio1575_sync() * * Description: * This is called by the framework to synchronize DMA caches. * * Arguments: * void *arg The DMA engine to sync */ static void audio1575_sync(void *arg, unsigned nframes) { audio1575_port_t *port = arg; _NOTE(ARGUNUSED(nframes)); (void) ddi_dma_sync(port->samp_dmah, 0, 0, port->sync_dir); } /* * audio1575_attach() * * Description: * Attach an instance of the audio1575 driver. This routine does the * device dependent attach tasks. When it is completed, it registers * with the audio framework. * * Arguments: * dev_info_t *dip Pointer to the device's dev_info struct * * Returns: * DDI_SUCCESS The driver was initialized properly * DDI_FAILURE The driver couldn't be initialized properly */ static int audio1575_attach(dev_info_t *dip) { audio1575_state_t *statep; audio_dev_t *adev; uint32_t devid; const char *name; const char *rev; int maxch; /* allocate the soft state structure */ statep = kmem_zalloc(sizeof (*statep), KM_SLEEP); ddi_set_driver_private(dip, statep); statep->dip = dip; /* * We want the micboost enabled by default as well. */ (void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, AC97_PROP_MICBOOST, 1); /* allocate common audio dev structure */ adev = audio_dev_alloc(dip, 0); if (adev == NULL) { audio_dev_warn(NULL, "unable to allocate audio dev"); goto error; } statep->adev = adev; /* map in the audio registers */ if (audio1575_map_regs(statep) != DDI_SUCCESS) { audio_dev_warn(adev, "couldn't map registers"); goto error; } /* Enable PCI I/O and Memory Spaces */ audio1575_pci_enable(statep); devid = (pci_config_get16(statep->pcih, PCI_CONF_VENID) << 16) | pci_config_get16(statep->pcih, PCI_CONF_DEVID); switch (devid) { case 0x10b95455: name = "Uli M1575 AC'97"; rev = "M5455"; break; default: name = "Uli AC'97"; rev = "Unknown"; break; } /* set device information -- this should check PCI config space */ audio_dev_set_description(adev, name); audio_dev_set_version(adev, rev); statep->ac97 = ac97_alloc(dip, audio1575_read_ac97, audio1575_write_ac97, statep); ASSERT(statep->ac97 != NULL); /* * Override "max-channels" property to prevent configuration * of 4 or 6 (or possibly even 8!) channel audio. The default * is to support as many channels as the hardware can do. */ maxch = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "max-channels", ac97_num_channels(statep->ac97)); if (maxch < 2) { maxch = 2; } statep->maxch = min(maxch, 6) & ~1; /* allocate port structures */ if ((audio1575_alloc_port(statep, M1575_PLAY, statep->maxch) != DDI_SUCCESS) || (audio1575_alloc_port(statep, M1575_REC, 2) != DDI_SUCCESS)) { goto error; } if (audio1575_chip_init(statep) != DDI_SUCCESS) { audio_dev_warn(adev, "failed to init chip"); goto error; } if (ac97_init(statep->ac97, adev) != DDI_SUCCESS) { audio_dev_warn(adev, "ac'97 initialization failed"); goto error; } /* register with the framework */ if (audio_dev_register(adev) != DDI_SUCCESS) { audio_dev_warn(adev, "unable to register with framework"); goto error; } /* everything worked out, so report the device */ ddi_report_dev(dip); return (DDI_SUCCESS); error: audio1575_destroy(statep); return (DDI_FAILURE); } /* * audio1575_detach() * * Description: * Detach an instance of the audio1575 driver. * * Arguments: * dev_info_t *dip Pointer to the device's dev_info struct * * Returns: * DDI_SUCCESS The driver was detached * DDI_FAILURE The driver couldn't be detached */ static int audio1575_detach(dev_info_t *dip) { audio1575_state_t *statep; statep = ddi_get_driver_private(dip); if (audio_dev_unregister(statep->adev) != DDI_SUCCESS) { return (DDI_FAILURE); } audio1575_destroy(statep); return (DDI_SUCCESS); } /* *********************** Local Routines *************************** */ /* * audio1575_alloc_port() * * Description: * This routine allocates the DMA handles and the memory for the * DMA engines to use. It also configures the BDL lists properly * for use. * * Arguments: * dev_info_t *dip Pointer to the device's devinfo * int num M1575_PLAY or M1575_REC * uint8_t nchan Number of channels (2 = stereo, 6 = 5.1, etc.) * * Returns: * DDI_SUCCESS Registers successfully mapped * DDI_FAILURE Registers not successfully mapped */ static int audio1575_alloc_port(audio1575_state_t *statep, int num, uint8_t nchan) { ddi_dma_cookie_t cookie; uint_t count; int dir; unsigned caps; audio_dev_t *adev; audio1575_port_t *port; uint32_t *kaddr; int rc; dev_info_t *dip; adev = statep->adev; dip = statep->dip; port = kmem_zalloc(sizeof (*port), KM_SLEEP); statep->ports[num] = port; port->num = num; port->statep = statep; port->nchan = nchan; if (num == M1575_REC) { dir = DDI_DMA_READ; caps = ENGINE_INPUT_CAP; port->sync_dir = DDI_DMA_SYNC_FORKERNEL; } else { dir = DDI_DMA_WRITE; caps = ENGINE_OUTPUT_CAP; port->sync_dir = DDI_DMA_SYNC_FORDEV; } /* * We use one big sample area. The sample area must be larger * than about 1.5 framework fragment sizes. (Currently 480 * * 1.5 = 720 frames.) This is necessary to ensure that we * don't have to involve an interrupt service routine on our * own, to keep the last valid index updated reasonably. */ port->nframes = 2048; port->samp_size = port->nframes * port->nchan * sizeof (int16_t); /* allocate dma handle */ rc = ddi_dma_alloc_handle(dip, &sample_buf_dma_attr, DDI_DMA_SLEEP, NULL, &port->samp_dmah); if (rc != DDI_SUCCESS) { audio_dev_warn(adev, "ddi_dma_alloc_handle failed: %d", rc); return (DDI_FAILURE); } /* allocate DMA buffer */ rc = ddi_dma_mem_alloc(port->samp_dmah, port->samp_size, &buf_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &port->samp_kaddr, &port->samp_size, &port->samp_acch); if (rc == DDI_FAILURE) { audio_dev_warn(adev, "dma_mem_alloc failed"); return (DDI_FAILURE); } /* bind DMA buffer */ rc = ddi_dma_addr_bind_handle(port->samp_dmah, NULL, port->samp_kaddr, port->samp_size, dir|DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &cookie, &count); if ((rc != DDI_DMA_MAPPED) || (count != 1)) { audio_dev_warn(adev, "ddi_dma_addr_bind_handle failed: %d", rc); return (DDI_FAILURE); } port->samp_paddr = cookie.dmac_address; /* * now, from here we allocate DMA memory for buffer descriptor list. * we allocate adjacent DMA memory for all DMA engines. */ rc = ddi_dma_alloc_handle(dip, &bdlist_dma_attr, DDI_DMA_SLEEP, NULL, &port->bdl_dmah); if (rc != DDI_SUCCESS) { audio_dev_warn(adev, "ddi_dma_alloc_handle(bdlist) failed"); return (DDI_FAILURE); } /* * we allocate all buffer descriptors lists in continuous dma memory. */ port->bdl_size = sizeof (m1575_bd_entry_t) * M1575_BD_NUMS; rc = ddi_dma_mem_alloc(port->bdl_dmah, port->bdl_size, &dev_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &port->bdl_kaddr, &port->bdl_size, &port->bdl_acch); if (rc != DDI_SUCCESS) { audio_dev_warn(adev, "ddi_dma_mem_alloc(bdlist) failed"); return (DDI_FAILURE); } /* * Wire up the BD list. We do this *before* binding the BD list * so that we don't have to do an extra ddi_dma_sync. */ kaddr = (void *)port->bdl_kaddr; for (int i = 0; i < M1575_BD_NUMS; i++) { /* set base address of buffer */ ddi_put32(port->bdl_acch, kaddr, port->samp_paddr); kaddr++; /* set size in frames, and enable IOC interrupt */ ddi_put32(port->bdl_acch, kaddr, ((port->samp_size / sizeof (int16_t)) | (1U << 31))); kaddr++; } rc = ddi_dma_addr_bind_handle(port->bdl_dmah, NULL, port->bdl_kaddr, port->bdl_size, DDI_DMA_WRITE|DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &cookie, &count); if ((rc != DDI_DMA_MAPPED) || (count != 1)) { audio_dev_warn(adev, "addr_bind_handle failed"); return (DDI_FAILURE); } port->bdl_paddr = cookie.dmac_address; port->engine = audio_engine_alloc(&audio1575_engine_ops, caps); if (port->engine == NULL) { audio_dev_warn(adev, "audio_engine_alloc failed"); return (DDI_FAILURE); } audio_engine_set_private(port->engine, port); audio_dev_add_engine(adev, port->engine); return (DDI_SUCCESS); } /* * audio1575_free_port() * * Description: * This routine unbinds the DMA cookies, frees the DMA buffers, * deallocates the DMA handles. * * Arguments: * audio1575_port_t *port The port structure for a DMA engine. */ static void audio1575_free_port(audio1575_port_t *port) { if (port == NULL) return; if (port->engine) { audio_dev_remove_engine(port->statep->adev, port->engine); audio_engine_free(port->engine); } if (port->bdl_paddr) { (void) ddi_dma_unbind_handle(port->bdl_dmah); } if (port->bdl_acch) { ddi_dma_mem_free(&port->bdl_acch); } if (port->bdl_dmah) { ddi_dma_free_handle(&port->bdl_dmah); } if (port->samp_paddr) { (void) ddi_dma_unbind_handle(port->samp_dmah); } if (port->samp_acch) { ddi_dma_mem_free(&port->samp_acch); } if (port->samp_dmah) { ddi_dma_free_handle(&port->samp_dmah); } kmem_free(port, sizeof (*port)); } /* * audio1575_map_regs() * * Description: * The registers are mapped in. * * Arguments: * dev_info_t *dip Pointer to the device's devinfo * * Returns: * DDI_SUCCESS Registers successfully mapped * DDI_FAILURE Registers not successfully mapped */ static int audio1575_map_regs(audio1575_state_t *statep) { dev_info_t *dip = statep->dip; /* map the M1575 Audio PCI Cfg Space */ if (pci_config_setup(dip, &statep->pcih) != DDI_SUCCESS) { audio_dev_warn(statep->adev, "PCI config map failure"); goto error; } /* map the M1575 Audio registers in PCI IO Space */ if ((ddi_regs_map_setup(dip, M1575_AUDIO_IO_SPACE, &statep->regsp, 0, 0, &dev_attr, &statep->regsh)) != DDI_SUCCESS) { audio_dev_warn(statep->adev, "Audio IO mapping failure"); goto error; } return (DDI_SUCCESS); error: audio1575_unmap_regs(statep); return (DDI_FAILURE); } /* * audio1575_unmap_regs() * * Description: * This routine unmaps control registers. * * Arguments: * audio1575_state_t *state The device's state structure */ static void audio1575_unmap_regs(audio1575_state_t *statep) { if (statep->regsh) { ddi_regs_map_free(&statep->regsh); } if (statep->pcih) { pci_config_teardown(&statep->pcih); } } /* * audio1575_chip_init() * * Description: * This routine initializes the M1575 AC97 audio controller and the AC97 * codec. The AC97 codec registers are programmed from codec_shadow[]. * If we are not doing a restore, we initialize codec_shadow[], otherwise * we use the current values of shadow. This routine expects that the * PCI IO and Memory spaces have been mapped and enabled already. * Arguments: * audio1575_state_t *state The device's state structure * restore from codec_shadow[] * Returns: * DDI_SUCCESS The hardware was initialized properly * DDI_FAILURE The hardware couldn't be initialized properly */ static int audio1575_chip_init(audio1575_state_t *statep) { uint32_t ssr; uint32_t rtsr; uint32_t intrsr; int i; int j; #ifdef __sparc uint8_t clk_detect; ddi_acc_handle_t pcih; #endif clock_t ticks; /* * clear the interrupt control and status register * READ/WRITE/READ workaround required * for buggy hardware */ PUT32(M1575_INTRCR_REG, 0); (void) GET32(M1575_INTRCR_REG); intrsr = GET32(M1575_INTRSR_REG); PUT32(M1575_INTRSR_REG, (intrsr & M1575_INTR_MASK)); (void) GET32(M1575_INTRSR_REG); ticks = drv_usectohz(M1575_LOOP_CTR); /* * SADA only supports stereo, so we set the channel bits * to "00" to select 2 channels. * will also set the following: * * Disable double rate enable * no SPDIF output selected * 16 bit audio record mode * 16 bit pcm out mode * PCM Out 6 chan mode FL FR CEN BL BR LFE * PCM Out 2 channel mode (00) */ for (i = 0; i < M1575_LOOP_CTR; i++) { /* Reset the AC97 Codec and default to 2 channel 16 bit mode */ PUT32(M1575_SCR_REG, M1575_SCR_COLDRST); delay(ticks<<1); /* Read the System Status Reg */ ssr = GET32(M1575_SSR_REG); /* make sure and release the blocked reset bit */ if (ssr & M1575_SSR_RSTBLK) { SET32(M1575_INTFCR_REG, M1575_INTFCR_RSTREL); delay(ticks); /* Read the System Status Reg */ ssr = GET32(M1575_SSR_REG); /* make sure and release the blocked reset bit */ if (ssr & M1575_SSR_RSTBLK) { return (DDI_FAILURE); } /* Reset the controller */ PUT32(M1575_SCR_REG, M1575_SCR_COLDRST); delay(ticks); } /* according AC'97 spec, wait for codec reset */ for (j = 0; j < M1575_LOOP_CTR; j++) { if ((GET32(M1575_SCR_REG) & M1575_SCR_COLDRST) == 0) { break; } delay(ticks); } /* codec reset failed */ if (j >= M1575_LOOP_CTR) { audio_dev_warn(statep->adev, "failure to reset codec"); return (DDI_FAILURE); } /* * Wait for FACRDY First codec ready. The hardware can * provide the state of * codec ready bit on SDATA_IN[0] and as reflected in * the Recv Tag Slot Reg. */ rtsr = GET32(M1575_RTSR_REG); if (rtsr & M1575_RTSR_FACRDY) { break; } else { /* reset the status and wait for new status to set */ rtsr |= M1575_RTSR_FACRDY; PUT32(M1575_RTSR_REG, rtsr); drv_usecwait(10); } } /* if we could not reset the AC97 codec then report failure */ if (i >= M1575_LOOP_CTR) { audio_dev_warn(statep->adev, "no codec ready signal received"); return (DDI_FAILURE); } #ifdef __sparc /* Magic code from ULi to Turn on the AC_LINK clock */ pcih = statep->pcih; pci_config_put8(pcih, M1575_PCIACD_REG, 0); pci_config_put8(pcih, M1575_PCIACD_REG, 4); pci_config_put8(pcih, M1575_PCIACD_REG, 0); (void) pci_config_get8(pcih, M1575_PCIACD_REG); pci_config_put8(pcih, M1575_PCIACD_REG, 2); pci_config_put8(pcih, M1575_PCIACD_REG, 0); clk_detect = pci_config_get8(pcih, M1575_PCIACD_REG); if (clk_detect != 1) { audio_dev_warn(statep->adev, "No AC97 Clock Detected"); return (DDI_FAILURE); } #endif /* Magic code from Uli to Init FIFO1 and FIFO2 */ PUT32(M1575_FIFOCR1_REG, 0x81818181); PUT32(M1575_FIFOCR2_REG, 0x81818181); PUT32(M1575_FIFOCR3_REG, 0x81818181); /* Make sure that PCM in and PCM out are enabled */ SET32(M1575_INTFCR_REG, (M1575_INTFCR_PCMIENB | M1575_INTFCR_PCMOENB)); audio1575_dma_stop(statep, B_FALSE); return (DDI_SUCCESS); } /* * audio1575_dma_stop() * * Description: * This routine is used to put each DMA engine into the quiet state. * * Arguments: * audio1575_state_t *statep The device's state structure */ static void audio1575_dma_stop(audio1575_state_t *statep, boolean_t quiesce) { uint32_t intrsr; int i; if (statep->regsh == NULL) { return; } /* pause bus master (needed for the following reset register) */ for (i = 0; i < M1575_LOOP_CTR; i++) { SET32(M1575_DMACR_REG, M1575_DMACR_PAUSE_ALL); if (GET32(M1575_DMACR_REG) & M1575_DMACR_PAUSE_ALL) { break; } drv_usecwait(10); } if (i >= M1575_LOOP_CTR) { if (!quiesce) audio_dev_warn(statep->adev, "failed to stop DMA"); return; } /* Pause bus master (needed for the following reset register) */ PUT8(M1575_PCMICR_REG, 0); PUT8(M1575_PCMOCR_REG, 0); PUT8(M1575_MICICR_REG, 0); PUT8(M1575_CSPOCR_REG, 0); PUT8(M1575_PCMI2CR_RR, 0); PUT8(M1575_MICI2CR_RR, 0); /* Reset the bus master registers for all DMA engines */ PUT8(M1575_PCMICR_REG, M1575_PCMICR_RR); PUT8(M1575_PCMOCR_REG, M1575_PCMOCR_RR); PUT8(M1575_MICICR_REG, M1575_MICICR_RR); PUT8(M1575_CSPOCR_REG, M1575_CSPOCR_RR); PUT8(M1575_PCMI2CR_REG, M1575_PCMI2CR_RR); PUT8(M1575_MICI2CR_REG, M1575_MICI2CR_RR); /* Reset FIFOS */ PUT32(M1575_FIFOCR1_REG, 0x81818181); PUT32(M1575_FIFOCR2_REG, 0x81818181); PUT32(M1575_FIFOCR3_REG, 0x81818181); /* Clear Interrupts */ SET16(M1575_PCMISR_REG, M1575_SR_CLR); SET16(M1575_PCMOSR_REG, M1575_SR_CLR); SET16(M1575_MICISR_REG, M1575_SR_CLR); SET16(M1575_CSPOSR_REG, M1575_SR_CLR); SET16(M1575_PCMI2SR_REG, M1575_SR_CLR); SET16(M1575_MICI2SR_REG, M1575_SR_CLR); /* * clear the interrupt control and status register * READ/WRITE/READ workaround required to flush PCI caches */ PUT32(M1575_INTRCR_REG, 0); (void) GET32(M1575_INTRCR_REG); intrsr = GET32(M1575_INTRSR_REG); PUT32(M1575_INTRSR_REG, (intrsr & M1575_INTR_MASK)); (void) GET32(M1575_INTRSR_REG); } /* * audio1575_codec_sync() * * Description: * Serialize access to the AC97 audio mixer registers. * * Arguments: * audio1575_state_t *state The device's state structure * * Returns: * DDI_SUCCESS Ready for an I/O access to the codec * DDI_FAILURE An I/O access is currently in progress, can't * perform another I/O access. */ static int audio1575_codec_sync(audio1575_state_t *statep) { /* do the Uli Shuffle ... */ for (int i = 0; i < M1575_LOOP_CTR; i++) { /* Read the semaphore, and loop till we own it */ if ((GET32(M1575_CASR_REG) & 1) == 0) { for (int j = 0; j < M1575_LOOP_CTR; j++) { /* Wait for CWRSUCC 0x8 */ if (GET32(M1575_CSPSR_REG) & M1575_CSPSR_SUCC) { return (DDI_SUCCESS); } drv_usecwait(1); } } drv_usecwait(10); } return (DDI_FAILURE); } /* * audio1575_write_ac97() * * Description: * Set the specific AC97 Codec register. * * Arguments: * void *arg The device's state structure * uint8_t reg AC97 register number * uint16_t data The data want to be set */ static void audio1575_write_ac97(void *arg, uint8_t reg, uint16_t data) { audio1575_state_t *statep = arg; int i; if (audio1575_codec_sync(statep) != DDI_SUCCESS) { return; } /* write the data to WRITE to the lo word of the CPR register */ PUT16(M1575_CPR_REG, data); /* write the address to WRITE to the hi word of the CPR register */ PUT16(M1575_CPR_REG+2, reg); /* wait until command is completed sucessfully */ for (i = 0; i < M1575_LOOP_CTR; i++) { /* Wait for Write Ready 0x01 */ if (GET32(M1575_CSPSR_REG) & M1575_CSPSR_WRRDY) { break; } drv_usecwait(1); } if (i < M1575_LOOP_CTR) { (void) audio1575_read_ac97(statep, reg); } } /* * audio1575_read_ac97() * * Description: * Get the specific AC97 Codec register. It also updates codec_shadow[] * with the register value. * * Arguments: * void *arg The device's state structure * uint8_t reg AC97 register number * * Returns: * Value of AC97 register. (0xffff in failure situations). */ static uint16_t audio1575_read_ac97(void *arg, uint8_t reg) { audio1575_state_t *statep = arg; uint16_t addr = 0; uint16_t data = 0xffff; int i; if ((audio1575_codec_sync(statep)) != DDI_SUCCESS) { return (data); } /* * at this point we have the CASR semaphore * and the codec is r/w ready * OR in the READ opcode into the address field */ addr = (reg | M1575_CPR_READ); /* write the address to READ to the hi word of the CPR register */ PUT16(M1575_CPR_REG+2, addr); /* wait until command is completed sucessfully */ for (i = 0; i < M1575_LOOP_CTR; i++) { /* Wait for Read Ready 0x02 */ if (GET32(M1575_CSPSR_REG) & M1575_CSPSR_RDRDY) { break; } drv_usecwait(1); } if (i < M1575_LOOP_CTR) { /* read back the data and address */ data = GET16(M1575_SPR_REG); addr = GET16(M1575_SPR_REG+2); if (addr != reg) { data = 0xffff; } } return (data); } /* * audio1575_pci_enable() * * Description: * This routine Enables all PCI IO and MEMORY accesses * * Arguments: * audio1575_state_t *statep The device's state structure */ static void audio1575_pci_enable(audio1575_state_t *statep) { uint16_t pcics_reg; pcics_reg = pci_config_get16(statep->pcih, PCI_CONF_COMM); pcics_reg |= (PCI_COMM_IO | PCI_COMM_MAE | PCI_COMM_ME); pci_config_put16(statep->pcih, PCI_CONF_COMM, pcics_reg); } /* * audio1575_pci_disable() * * Description: * This routine Disables all PCI IO and MEMORY accesses * * Arguments: * audio1575_state_t *statep The device's state structure */ static void audio1575_pci_disable(audio1575_state_t *statep) { uint16_t pcics_reg; if (statep->pcih == NULL) return; pcics_reg = pci_config_get16(statep->pcih, PCI_CONF_COMM); pcics_reg &= ~(PCI_COMM_IO | PCI_COMM_MAE | PCI_COMM_ME); pci_config_put16(statep->pcih, PCI_CONF_COMM, pcics_reg); } /* * audio1575_resume() * * Description: * Resume operation of the device after sleeping or hibernating. * Note that this should never fail, even if hardware goes wonky, * because the current PM framework will panic if it does. * * Arguments: * dev_info_t *dip Pointer to the device's dev_info struct * * Returns: * DDI_SUCCESS The driver was resumed */ static int audio1575_resume(dev_info_t *dip) { audio1575_state_t *statep; audio_dev_t *adev; /* we've already allocated the state structure so get ptr */ statep = ddi_get_driver_private(dip); adev = statep->adev; ASSERT(!mutex_owned(&statep->lock)); if (audio1575_chip_init(statep) != DDI_SUCCESS) { /* * Note that PM gurus say we should return * success here. Failure of audio shouldn't * be considered FATAL to the system. The * upshot is that audio will not progress. */ audio_dev_warn(adev, "DDI_RESUME failed to init chip"); return (DDI_SUCCESS); } /* allow ac97 operations again */ ac97_reset(statep->ac97); audio_dev_resume(adev); return (DDI_SUCCESS); } /* * audio1575_suspend() * * Description: * Suspend an instance of the audio1575 driver. * * Arguments: * dev_info_t *dip Pointer to the device's dev_info struct * * Returns: * DDI_SUCCESS The driver was suspended */ static int audio1575_suspend(dev_info_t *dip) { audio1575_state_t *statep; statep = ddi_get_driver_private(dip); audio_dev_suspend(statep->adev); return (DDI_SUCCESS); } /* * audio1575_destroy() * * Description: * This routine releases all resources held by the device instance, * as part of either detach or a failure in attach. * * Arguments: * audio1575_state_t *state The device soft state. */ void audio1575_destroy(audio1575_state_t *statep) { ddi_acc_handle_t pcih; /* stop DMA engines */ audio1575_dma_stop(statep, B_FALSE); if (statep->regsh != NULL) { /* reset the codec */ PUT32(M1575_SCR_REG, M1575_SCR_COLDRST); } if ((pcih = statep->pcih) != NULL) { /* turn off the AC_LINK clock */ pci_config_put8(pcih, M1575_PCIACD_REG, 0); pci_config_put8(pcih, M1575_PCIACD_REG, 4); pci_config_put8(pcih, M1575_PCIACD_REG, 0); } /* Disable PCI I/O and Memory Spaces */ audio1575_pci_disable(statep); audio1575_free_port(statep->ports[M1575_PLAY]); audio1575_free_port(statep->ports[M1575_REC]); audio1575_unmap_regs(statep); if (statep->ac97 != NULL) { ac97_free(statep->ac97); } if (statep->adev != NULL) { audio_dev_free(statep->adev); } kmem_free(statep, sizeof (*statep)); }