i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

another attempt, but still broken

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@7141 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
beveloper
2004-04-02 22:21:46 +00:00
parent 9a9f64e114
commit 9a424d11b4
6 changed files with 372 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/drivers/audio/ac97/ichaudio/ichaudio.c
+222 -42
View File
@@ -2,9 +2,15 @@
#include "ichaudio.h" #include "ichaudio.h"
#include "io.h" #include "io.h"
status_t ichaudio_attach(audio_drv_t *drv); status_t ichaudio_attach(audio_drv_t *drv, void **cookie);
status_t ichaudio_powerctl(audio_drv_t *drv); status_t ichaudio_powerctl(audio_drv_t *drv, void *cookie);
status_t ichaudio_detach(audio_drv_t *drv); status_t ichaudio_detach(audio_drv_t *drv, void *cookie);
status_t ichaudio_stream_attach(audio_drv_t *drv, void **cookie, void *param);
status_t ichaudio_stream_detach(audio_drv_t *drv, void *cookie);
status_t ichaudio_stream_control(audio_drv_t *drv, void *cookie, int op);
status_t ichaudio_stream_set_buffers(audio_drv_t *drv, void *cookie, uint32 *buffer_size, stream_buffer_desc_t *desc);
status_t ichaudio_stream_set_frame_rate(audio_drv_t *drv, void *cookie, uint32 *frame_rate);
id_table_t ichaudio_id_table[] = { id_table_t ichaudio_id_table[] = {
{ 0x8086, 0x7195, -1, -1, -1, -1, -1, "Intel 82443MX AC97 audio" }, { 0x8086, 0x7195, -1, -1, -1, -1, -1, "Intel 82443MX AC97 audio" },
@@ -12,9 +18,9 @@ id_table_t ichaudio_id_table[] = {
{ 0x8086, 0x2425, -1, -1, -1, -1, -1, "Intel 82801AB (ICH0) AC97 audio" }, { 0x8086, 0x2425, -1, -1, -1, -1, -1, "Intel 82801AB (ICH0) AC97 audio" },
{ 0x8086, 0x2445, -1, -1, -1, -1, -1, "Intel 82801BA (ICH2) AC97 audio" }, { 0x8086, 0x2445, -1, -1, -1, -1, -1, "Intel 82801BA (ICH2) AC97 audio" },
{ 0x8086, 0x2485, -1, -1, -1, -1, -1, "Intel 82801CA (ICH3) AC97 audio" }, { 0x8086, 0x2485, -1, -1, -1, -1, -1, "Intel 82801CA (ICH3) AC97 audio" },
{ 0x8086, 0x24C5, -1, -1, -1, -1, -1, "Intel 82801DB (ICH4) AC97 audio", TYPE_ICH4 }, { 0x8086, 0x24C5, -1, -1, -1, -1, -1, "Intel 82801DB (ICH4) AC97 audio", (void *)TYPE_ICH4 },
{ 0x8086, 0x24D5, -1, -1, -1, -1, -1, "Intel 82801EB (ICH5) AC97 audio", TYPE_ICH4 }, { 0x8086, 0x24D5, -1, -1, -1, -1, -1, "Intel 82801EB (ICH5) AC97 audio", (void *)TYPE_ICH4 },
{ 0x1039, 0x7012, -1, -1, -1, -1, -1, "SiS SI7012 AC97 audio", TYPE_SIS7012 }, { 0x1039, 0x7012, -1, -1, -1, -1, -1, "SiS SI7012 AC97 audio", (void *)TYPE_SIS7012 },
{ 0x10DE, 0x01B1, -1, -1, -1, -1, -1, "NVIDIA nForce (MCP) AC97 audio" }, { 0x10DE, 0x01B1, -1, -1, -1, -1, -1, "NVIDIA nForce (MCP) AC97 audio" },
{ 0x10DE, 0x006A, -1, -1, -1, -1, -1, "NVIDIA nForce 2 (MCP2) AC97 audio" }, { 0x10DE, 0x006A, -1, -1, -1, -1, -1, "NVIDIA nForce 2 (MCP2) AC97 audio" },
{ 0x10DE, 0x00DA, -1, -1, -1, -1, -1, "NVIDIA nForce 3 (MCP3) AC97 audio" }, { 0x10DE, 0x00DA, -1, -1, -1, -1, -1, "NVIDIA nForce 3 (MCP3) AC97 audio" },
@@ -29,19 +35,56 @@ id_table_t ichaudio_id_table[] = {
driver_info_t driver_info = { driver_info_t driver_info = {
.table = ichaudio_id_table, .id_table = ichaudio_id_table,
.basename = "audio/lala/ichaudio", .basename = "audio/lala/ichaudio",
.cookie_size = sizeof(ichaudio_cookie),
.attach = ichaudio_attach, .attach = ichaudio_attach,
.detach = ichaudio_detach, .detach = ichaudio_detach,
.powerctl = ichaudio_powerctl, .powerctl = ichaudio_powerctl,
}; };
stream_info_t po_stream = {
.flags = B_PLAYBACK_STREAM | B_BUFFER_SIZE_EXPONETIAL | B_SAMPLE_TYPE_INT16,
.cookie_size = sizeof(ichaudio_stream_cookie),
.sample_bits = 16,
.channel_count = 2,
.channel_mask = B_CHANNEL_LEFT | B_CHANNEL_RIGHT,
.frame_rate_min = 0, // is setup later after device probing
.frame_rate_max = 0, // is setup later after device probing
.frame_rate_mask = 0, // is setup later after device probing
.buffer_size_min = 256,
.buffer_size_max = 32768,
.buffer_count = 2,
.attach = ichaudio_stream_attach,
.detach = ichaudio_stream_detach,
.control = ichaudio_stream_control,
.set_buffers = ichaudio_stream_set_buffers,
.set_frame_rate = ichaudio_stream_set_frame_rate,
};
stream_info_t pi_stream = {
.flags = B_RECORDING_STREAM | B_BUFFER_SIZE_EXPONETIAL | B_SAMPLE_TYPE_INT16,
.sample_bits = 16,
.channel_count = 2,
.channel_mask = B_CHANNEL_LEFT | B_CHANNEL_RIGHT,
.frame_rate_min = 0, // is setup later after device probing
.frame_rate_max = 0, // is setup later after device probing
.frame_rate_mask = 0, // is setup later after device probing
.buffer_size_min = 256,
.buffer_size_max = 32768,
.buffer_count = 2,
.attach = ichaudio_stream_attach,
.detach = ichaudio_stream_detach,
.control = ichaudio_stream_control,
.set_buffers = ichaudio_stream_set_buffers,
.set_frame_rate = ichaudio_stream_set_frame_rate,
};
status_t status_t
ichaudio_attach(audio_drv_t *drv) ichaudio_attach(audio_drv_t *drv, void **_cookie)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie; ichaudio_cookie *cookie;
uint32 value; uint32 value;
int i; int i;
bigtime_t start; bigtime_t start;
@@ -49,10 +92,15 @@ ichaudio_attach(audio_drv_t *drv)
dprintf("ichaudio_attach\n"); dprintf("ichaudio_attach\n");
*_cookie = cookie = (ichaudio_cookie *) malloc(sizeof(ichaudio_cookie));
cookie->pci = drv->pci;
cookie->flags = (uint32)drv->param;
// For old ICHs enable programmed IO and busmaster access, // For old ICHs enable programmed IO and busmaster access,
// for ICH4 and up enable memory mapped IO and busmaster access // for ICH4 and up enable memory mapped IO and busmaster access
value = drv->pci->read_pci_config(drv->bus, drv->device, drv->function, PCI_command, 2); value = drv->pci->read_pci_config(drv->bus, drv->device, drv->function, PCI_command, 2);
value |= PCI_PCICMD_BME | (drv->flags & TYPE_ICH4) ? PCI_PCICMD_MSE : PCI_PCICMD_IOS; value |= PCI_PCICMD_BME | (cookie->flags & TYPE_ICH4) ? PCI_PCICMD_MSE : PCI_PCICMD_IOS;
drv->pci->write_pci_config(drv->bus, drv->device, drv->function, PCI_command, 2, value); drv->pci->write_pci_config(drv->bus, drv->device, drv->function, PCI_command, 2, value);
// get IRQ, we can compensate it later if IRQ is not available (hack!) // get IRQ, we can compensate it later if IRQ is not available (hack!)
@@ -60,17 +108,17 @@ ichaudio_attach(audio_drv_t *drv)
if (cookie->irq == 0xff) cookie->irq = 0; if (cookie->irq == 0xff) cookie->irq = 0;
if (cookie->irq == 0) dprintf("ichaudio_attach: no interrupt configured\n"); if (cookie->irq == 0) dprintf("ichaudio_attach: no interrupt configured\n");
if (drv->flags & TYPE_ICH4) { if (cookie->flags & TYPE_ICH4) {
// memory mapped access // memory mapped access
uint32 phy_mmbar = PCI_address_memory_32_mask & drv->pci->read_pci_config(drv->bus, drv->device, drv->function, 0x18, 4); uint32 phys_mmbar = PCI_address_memory_32_mask & drv->pci->read_pci_config(drv->bus, drv->device, drv->function, 0x18, 4);
uint32 phy_mbbar = PCI_address_memory_32_mask & drv->pci->read_pci_config(drv->bus, drv->device, drv->function, 0x1C, 4); uint32 phys_mbbar = PCI_address_memory_32_mask & drv->pci->read_pci_config(drv->bus, drv->device, drv->function, 0x1C, 4);
if (!phy_mmbar || !phy_mbbar) { if (!phys_mmbar || !phys_mbbar) {
dprintf("ichaudio_attach: memory mapped io unconfigured\n"); dprintf("ichaudio_attach: memory mapped io unconfigured\n");
goto err; goto err;
} }
// map into memory // map into memory
cookie->area_mmbar = map_mem(&cookie->mmbar, (void *)phy_mmbar, ICH4_MMBAR_SIZE, 0, "ichaudio mmbar io"); cookie->area_mmbar = map_mem(&cookie->mmbar, (void *)phys_mmbar, ICH4_MMBAR_SIZE, 0, "ichaudio mmbar io");
cookie->area_mbbar = map_mem(&cookie->mbbar, (void *)phy_mbbar, ICH4_MBBAR_SIZE, 0, "ichaudio mbbar io"); cookie->area_mbbar = map_mem(&cookie->mbbar, (void *)phys_mbbar, ICH4_MBBAR_SIZE, 0, "ichaudio mbbar io");
if (cookie->area_mmbar < B_OK || cookie->area_mbbar < B_OK) { if (cookie->area_mmbar < B_OK || cookie->area_mbbar < B_OK) {
dprintf("ichaudio_attach: mapping io into memory failed\n"); dprintf("ichaudio_attach: mapping io into memory failed\n");
goto err; goto err;
@@ -97,34 +145,34 @@ ichaudio_attach(audio_drv_t *drv)
* reset does also reset GPIO pins, but the ICH hardware does only execute * reset does also reset GPIO pins, but the ICH hardware does only execute
* the reset request if BIT_CLOCK is not running and if it's really required. * the reset request if BIT_CLOCK is not running and if it's really required.
*/ */
LOG(("reset starting, ICH_REG_GLOB_CNT = 0x%08x\n", ich_reg_read_32(drv, ICH_REG_GLOB_CNT))); LOG(("reset starting, ICH_REG_GLOB_CNT = 0x%08lx\n", ich_reg_read_32(cookie, ICH_REG_GLOB_CNT)));
DEBUG_ONLY(start = system_time()); start = system_time();
// finish cold reset by writing a 1 and clear all other bits to 0 // finish cold reset by writing a 1 and clear all other bits to 0
ich_reg_write_32(drv, ICH_REG_GLOB_CNT, CNT_COLD); ich_reg_write_32(cookie, ICH_REG_GLOB_CNT, CNT_COLD);
ich_reg_read_32(drv, ICH_REG_GLOB_CNT); // force PCI-to-PCI bridge cache flush ich_reg_read_32(cookie, ICH_REG_GLOB_CNT); // force PCI-to-PCI bridge cache flush
snooze(20000); snooze(20000);
// request warm reset by setting the bit, it will clear when reset is done // request warm reset by setting the bit, it will clear when reset is done
ich_reg_write_32(drv, ICH_REG_GLOB_CNT, ich_reg_read_32(drv, ICH_REG_GLOB_CNT) | CNT_WARM); ich_reg_write_32(cookie, ICH_REG_GLOB_CNT, ich_reg_read_32(cookie, ICH_REG_GLOB_CNT) | CNT_WARM);
ich_reg_read_32(drv, ICH_REG_GLOB_CNT); // force PCI-to-PCI bridge cache flush ich_reg_read_32(cookie, ICH_REG_GLOB_CNT); // force PCI-to-PCI bridge cache flush
snooze(20000); snooze(20000);
// wait up to 1 second for warm reset to be finished // wait up to 1 second for warm reset to be finished
for (i = 0; i < 20; i++) { for (i = 0; i < 20; i++) {
value = ich_reg_read_32(drv, ICH_REG_GLOB_CNT); value = ich_reg_read_32(cookie, ICH_REG_GLOB_CNT);
if ((value & CNT_WARM) == 0 && (value & CNT_COLD) != 0) if ((value & CNT_WARM) == 0 && (value & CNT_COLD) != 0)
break; break;
snooze(50000); snooze(50000);
} }
if (i == 20) { if (i == 20) {
LOG(("reset failed, ICH_REG_GLOB_CNT = 0x%08x\n", value)); LOG(("reset failed, ICH_REG_GLOB_CNT = 0x%08lx\n", value));
goto err; goto err;
} }
LOG(("reset finished after %Ld, ICH_REG_GLOB_CNT = 0x%08x\n", system_time() - start, value)); LOG(("reset finished after %Ld, ICH_REG_GLOB_CNT = 0x%08lx\n", system_time() - start, value));
/* detect which codecs are ready */ /* detect which codecs are ready */
s0cr = s1cr = s2cr = false; s0cr = s1cr = s2cr = false;
start = system_time(); start = system_time();
do { do {
value = ich_reg_read_32(drv, ICH_REG_GLOB_STA); value = ich_reg_read_32(cookie, ICH_REG_GLOB_STA);
if (!s0cr && (value & STA_S0CR)) { if (!s0cr && (value & STA_S0CR)) {
s0cr = true; s0cr = true;
LOG(("AC_SDIN0 codec ready after %Ld us\n", system_time() - start)); LOG(("AC_SDIN0 codec ready after %Ld us\n", system_time() - start));
@@ -155,40 +203,40 @@ ichaudio_attach(audio_drv_t *drv)
goto err; goto err;
} }
if (drv->flags & TYPE_ICH4) { if (cookie->flags & TYPE_ICH4) {
/* we are using a ICH4 chipset, and assume that the codec beeing ready /* we are using a ICH4 chipset, and assume that the codec beeing ready
* is the primary one. * is the primary one.
*/ */
uint8 sdin; uint8 sdin;
uint16 reset; uint16 reset;
uint8 id; uint8 id;
reset = ich_codec_read(drv, 0x00); /* access the primary codec */ reset = ich_codec_read(cookie, 0x00); /* access the primary codec */
if (reset == 0 || reset == 0xFFFF) { if (reset == 0 || reset == 0xFFFF) {
LOG(("primary codec not present\n")); LOG(("primary codec not present\n"));
} else { } else {
sdin = 0x02 & ich_reg_read_8(drv, ICH_REG_SDM); sdin = 0x02 & ich_reg_read_8(cookie, ICH_REG_SDM);
id = 0x02 & (ich_codec_read(drv, 0x00 + 0x28) >> 14); id = 0x02 & (ich_codec_read(cookie, 0x00 + 0x28) >> 14);
LOG(("primary codec id %d is connected to AC_SDIN%d\n", id, sdin)); LOG(("primary codec id %d is connected to AC_SDIN%d\n", id, sdin));
} }
reset = ich_codec_read(drv, 0x80); /* access the secondary codec */ reset = ich_codec_read(cookie, 0x80); /* access the secondary codec */
if (reset == 0 || reset == 0xFFFF) { if (reset == 0 || reset == 0xFFFF) {
LOG(("secondary codec not present\n")); LOG(("secondary codec not present\n"));
} else { } else {
sdin = 0x02 & ich_reg_read_8(drv, ICH_REG_SDM); sdin = 0x02 & ich_reg_read_8(cookie, ICH_REG_SDM);
id = 0x02 & (ich_codec_read(drv, 0x80 + 0x28) >> 14); id = 0x02 & (ich_codec_read(cookie, 0x80 + 0x28) >> 14);
LOG(("secondary codec id %d is connected to AC_SDIN%d\n", id, sdin)); LOG(("secondary codec id %d is connected to AC_SDIN%d\n", id, sdin));
} }
reset = ich_codec_read(drv, 0x100); /* access the tertiary codec */ reset = ich_codec_read(cookie, 0x100); /* access the tertiary codec */
if (reset == 0 || reset == 0xFFFF) { if (reset == 0 || reset == 0xFFFF) {
LOG(("tertiary codec not present\n")); LOG(("tertiary codec not present\n"));
} else { } else {
sdin = 0x02 & ich_reg_read_8(drv, ICH_REG_SDM); sdin = 0x02 & ich_reg_read_8(cookie, ICH_REG_SDM);
id = 0x02 & (ich_codec_read(drv, 0x100 + 0x28) >> 14); id = 0x02 & (ich_codec_read(cookie, 0x100 + 0x28) >> 14);
LOG(("tertiary codec id %d is connected to AC_SDIN%d\n", id, sdin)); LOG(("tertiary codec id %d is connected to AC_SDIN%d\n", id, sdin));
} }
/* XXX this may be wrong */ /* XXX this may be wrong */
ich_reg_write_8(drv, ICH_REG_SDM, (ich_reg_read_8(drv, ICH_REG_SDM) & 0x0F) | 0x08 | 0x90); ich_reg_write_8(cookie, ICH_REG_SDM, (ich_reg_read_8(cookie, ICH_REG_SDM) & 0x0F) | 0x08 | 0x90);
} else { } else {
/* we are using a pre-ICH4 chipset, that has a fixed mapping of /* we are using a pre-ICH4 chipset, that has a fixed mapping of
* AC_SDIN0 = primary, AC_SDIN1 = secondary codec. * AC_SDIN0 = primary, AC_SDIN1 = secondary codec.
@@ -200,36 +248,168 @@ ichaudio_attach(audio_drv_t *drv)
} }
} }
cookie->po_stream_id = create_stream(&po_stream, (void *)ICH_REG_PO_BASE);
cookie->pi_stream_id = create_stream(&pi_stream, (void *)ICH_REG_PI_BASE);
if (cookie->po_stream_id < 0 || cookie->pi_stream_id < 0)
goto err;
return B_OK; return B_OK;
err: err:
// delete streams
if (cookie->po_stream_id > 0) delete_stream(cookie->po_stream_id);
if (cookie->pi_stream_id > 0) delete_stream(cookie->pi_stream_id);
// unmap io memory // unmap io memory
if (cookie->area_mmbar > 0) delete_area(cookie->area_mmbar); if (cookie->area_mmbar > 0) delete_area(cookie->area_mmbar);
if (cookie->area_mbbar > 0) delete_area(cookie->area_mbbar); if (cookie->area_mbbar > 0) delete_area(cookie->area_mbbar);
free(cookie);
return B_ERROR; return B_ERROR;
} }
status_t status_t
ichaudio_detach(audio_drv_t *drv) ichaudio_detach(audio_drv_t *drv, void *_cookie)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie; ichaudio_cookie *cookie = (ichaudio_cookie *)_cookie;
dprintf("ichaudio_detach\n"); dprintf("ichaudio_detach\n");
// delete streams
if (cookie->po_stream_id > 0) delete_stream(cookie->po_stream_id);
if (cookie->pi_stream_id > 0) delete_stream(cookie->pi_stream_id);
// unmap io memory // unmap io memory
if (cookie->area_mmbar > 0) delete_area(cookie->area_mmbar); if (cookie->area_mmbar > 0) delete_area(cookie->area_mmbar);
if (cookie->area_mbbar > 0) delete_area(cookie->area_mbbar); if (cookie->area_mbbar > 0) delete_area(cookie->area_mbbar);
free(cookie);
return B_OK; return B_OK;
} }
status_t status_t
ichaudio_powerctl(audio_drv_t *drv) ichaudio_powerctl(audio_drv_t *drv, void *_cookie)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie; ichaudio_cookie *cookie = (ichaudio_cookie *)_cookie;
return B_OK; return B_OK;
} }
void
stream_reset(ichaudio_stream_cookie *cookie)
{
int i;
ich_reg_write_8(cookie, cookie->regbase + ICH_REG_X_CR, 0);
ich_reg_read_8(cookie, cookie->regbase + ICH_REG_X_CR); // force PCI-to-PCI bridge cache flush
snooze(10000); // 10 ms
ich_reg_write_8(cookie, cookie->regbase + ICH_REG_X_CR, CR_RR);
for (i = 0; i < 100; i++) {
uint8 cr = ich_reg_read_8(cookie, cookie->regbase + ICH_REG_X_CR);
if (cr == 0) {
LOG(("channel reset finished, %d\n",i));
return;
}
snooze(100);
}
LOG(("channel reset failed after 10ms\n"));
}
status_t
ichaudio_stream_attach(audio_drv_t *drv, void **_cookie, void *param)
{
ichaudio_stream_cookie *cookie;
void *bd_virt_base;
void *bd_phys_base;
int i;
*_cookie = cookie = (ichaudio_stream_cookie *) malloc(sizeof(ichaudio_stream_cookie));
cookie->regbase = (uint32) param;
cookie->lastindex = 0;
cookie->processed_samples = 0;
stream_reset(cookie);
// allocate memory for buffer descriptors
cookie->bd_area = alloc_mem(&bd_virt_base, &bd_phys_base, ICH_BD_COUNT * sizeof(ich_bd), 0, "ich_ac97 buffer descriptor");
if (cookie->bd_area < B_OK)
goto err;
// set physical buffer descriptor base address
ich_reg_write_32(cookie->regbase, (uint32)bd_phys_base);
// setup descriptor pointers
for (i = 0; i < ICH_BD_COUNT; i++)
cookie->bd[i] = (ich_bd *) ((char *)bd_virt_base + i * sizeof(ich_bd));
return B_OK;
err:
free(cookie);
return B_ERROR;
}
status_t
ichaudio_stream_detach(audio_drv_t *drv, void *_cookie)
{
ichaudio_stream_cookie *cookie = (ichaudio_stream_cookie *)_cookie;
stream_reset(cookie);
if (cookie->buffer_area > 0) delete_area(cookie->buffer_area);
if (cookie->bd_area > 0) delete_area(cookie->bd_area);
free(cookie);
return B_OK;
}
status_t
ichaudio_stream_control(audio_drv_t *drv, void *_cookie, int op)
{
}
status_t
ichaudio_stream_set_buffers(audio_drv_t *drv, void *_cookie, uint32 *buffer_size, stream_buffer_desc_t *desc)
{
ichaudio_stream_cookie *cookie = (ichaudio_stream_cookie *)_cookie;
void *buffer_virt_base;
void *buffer_phys_base;
area_id buffer_area;
int i;
// round down (could force another size here)
*buffer_size &= ~3;
// allocate memory buffers
buffer_area = alloc_mem(&buffer_virt_base, &buffer_phys_base, 2 * *buffer_size, B_READ_AREA | B_WRITE_AREA, "ich_ac97 buffers");
// report buffers
desc[0].base = (char *)buffer_virt_base;
desc[0].stride = 4;
desc[1].base = (char *)buffer_virt_base + 2;
desc[1].stride = 4;
// initalize buffer descriptors
for (i = 0; i < ICH_BD_COUNT; i++) {
cookie->bd[i].buffer = (uint32)buffer_phy_base + (i % 2) * *buffer_size;
cookie->bd[i].length = *buffer_size / GET_HW_SAMPLE_SIZE(cookie);
cookie->bd[i].flags = ICH_BDC_FLAG_IOC;
}
// free old buffer memory
if (cookie->buffer_area > 0)
delete_area(cookie->buffer_area);
cookie->buffer_area = buffer_area;
return B_OK;
}
status_t
ichaudio_stream_set_frame_rate(audio_drv_t *drv, void *_cookie, uint32 *frame_rate)
{
}
src/add-ons/kernel/drivers/audio/ac97/ichaudio/ichaudio.h
+25 -3
View File
@@ -1,5 +1,6 @@
#include <SupportDefs.h> #include <SupportDefs.h>
#include "hardware.h" #include "hardware.h"
#include "lala/lala.h"
typedef struct typedef struct
{ {
@@ -15,15 +16,36 @@ typedef struct
uint32 input_rate; uint32 input_rate;
uint32 output_rate; uint32 output_rate;
stream_id po_stream_id;
stream_id pi_stream_id;
pci_module_info * pci;
uint32 flags;
} ichaudio_cookie; } ichaudio_cookie;
typedef struct
{
uint32 regbase;
ich_bd * bd[ICH_BD_COUNT];
void * buffer[ICH_BD_COUNT];
area_id bd_area;
area_id buffer_area;
volatile int lastindex;
volatile int64 processed_samples;
} ichaudio_stream_cookie;
#define TYPE_ICH4 0x01 #define TYPE_ICH4 0x01
#define TYPE_SIS7012 0x02 #define TYPE_SIS7012 0x02
/* The SIS7012 chipset has SR and PICB registers swapped when compared to Intel */ /* The SIS7012 chipset has SR and PICB registers swapped when compared to Intel */
#define GET_REG_X_PICB(cfg) (((cfg)->type == TYPE_SIS7012) ? _ICH_REG_X_SR : _ICH_REG_X_PICB) #define GET_REG_X_PICB(cookie) (((cookie)->flags & TYPE_SIS7012) ? _ICH_REG_X_SR : _ICH_REG_X_PICB)
#define GET_REG_X_SR(cfg) (((cfg)->type == TYPE_SIS7012) ? _ICH_REG_X_PICB : _ICH_REG_X_SR) #define GET_REG_X_SR(cookie) (((cookie)->flags & TYPE_SIS7012) ? _ICH_REG_X_PICB : _ICH_REG_X_SR)
/* Each 16 bit sample is counted as 1 in SIS7012 chipsets, 2 in all others */ /* Each 16 bit sample is counted as 1 in SIS7012 chipsets, 2 in all others */
#define GET_HW_SAMPLE_SIZE(cfg) (((cfg)->type == TYPE_SIS7012) ? 1 : 2) #define GET_HW_SAMPLE_SIZE(cookie) (((cookie)->flags & TYPE_SIS7012) ? 1 : 2)
src/add-ons/kernel/drivers/audio/ac97/ichaudio/io.c
+39 -51
View File
@@ -32,96 +32,84 @@
#include "ichaudio.h" #include "ichaudio.h"
#include "io.h" #include "io.h"
status_t ich_codec_wait(audio_drv_t *drv); status_t ich_codec_wait(ichaudio_cookie *cookie);
uint8 uint8
ich_reg_read_8(audio_drv_t *drv, int regno) ich_reg_read_8(ichaudio_cookie *cookie, int regno)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63);
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
return *(uint8 *)((char *)cookie->mbbar + regno); return *(uint8 *)((char *)cookie->mbbar + regno);
else else
return drv->pci->read_io_8(cookie->nabmbar + regno); return cookie->pci->read_io_8(cookie->nabmbar + regno);
} }
uint16 uint16
ich_reg_read_16(audio_drv_t *drv, int regno) ich_reg_read_16(ichaudio_cookie *cookie, int regno)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63);
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
return *(uint16 *)((char *)cookie->mbbar + regno); return *(uint16 *)((char *)cookie->mbbar + regno);
else else
return drv->pci->read_io_16(cookie->nabmbar + regno); return cookie->pci->read_io_16(cookie->nabmbar + regno);
} }
uint32 uint32
ich_reg_read_32(audio_drv_t *drv, int regno) ich_reg_read_32(ichaudio_cookie *cookie, int regno)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63);
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
return *(uint32 *)((char *)cookie->mbbar + regno); return *(uint32 *)((char *)cookie->mbbar + regno);
else else
return drv->pci->read_io_32(cookie->nabmbar + regno); return cookie->pci->read_io_32(cookie->nabmbar + regno);
} }
void void
ich_reg_write_8(audio_drv_t *drv, int regno, uint8 value) ich_reg_write_8(ichaudio_cookie *cookie, int regno, uint8 value)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63);
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
*(uint8 *)((char *)cookie->mbbar + regno) = value; *(uint8 *)((char *)cookie->mbbar + regno) = value;
else else
drv->pci->write_io_8(cookie->nabmbar + regno, value); cookie->pci->write_io_8(cookie->nabmbar + regno, value);
} }
void void
ich_reg_write_16(audio_drv_t *drv, int regno, uint16 value) ich_reg_write_16(ichaudio_cookie *cookie, int regno, uint16 value)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63);
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
*(uint16 *)((char *)cookie->mbbar + regno) = value; *(uint16 *)((char *)cookie->mbbar + regno) = value;
else else
drv->pci->write_io_16(cookie->nabmbar + regno, value); cookie->pci->write_io_16(cookie->nabmbar + regno, value);
} }
void void
ich_reg_write_32(audio_drv_t *drv, int regno, uint32 value) ich_reg_write_32(ichaudio_cookie *cookie, int regno, uint32 value)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 255) || regno <= 63);
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
*(uint32 *)((char *)cookie->mbbar + regno) = value; *(uint32 *)((char *)cookie->mbbar + regno) = value;
else else
drv->pci->write_io_32(cookie->nabmbar + regno, value); cookie->pci->write_io_32(cookie->nabmbar + regno, value);
} }
status_t status_t
ich_codec_wait(audio_drv_t *drv) ich_codec_wait(ichaudio_cookie *cookie)
{ {
int i; int i;
for (i = 0; i < 1100; i++) { for (i = 0; i < 1100; i++) {
if ((ich_reg_read_8(drv, ICH_REG_ACC_SEMA) & 0x01) == 0) if ((ich_reg_read_8(cookie, ICH_REG_ACC_SEMA) & 0x01) == 0)
return B_OK; return B_OK;
if (i > 100) if (i > 100)
snooze(1); snooze(1);
@@ -130,39 +118,39 @@ ich_codec_wait(audio_drv_t *drv)
} }
uint16 uint16
ich_codec_read(audio_drv_t *drv, int regno) ich_codec_read(void *_cookie, int regno)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie; ichaudio_cookie *cookie = (ichaudio_cookie *)_cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT((regno & 1) == 0); ASSERT((regno & 1) == 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 511) || regno <= 255); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 511) || regno <= 255);
if (regno == 0x54) // intel uses 0x54 for GPIO access, we filter it! if (regno == 0x54) // intel uses 0x54 for GPIO access, we filter it!
return 0; return 0;
if (B_OK != ich_codec_wait(drv)) if (B_OK != ich_codec_wait(cookie))
PRINT(("semaphore timeout reading register %#x\n", regno)); PRINT(("semaphore timeout reading register %#x\n", regno));
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
return *(uint16 *)(((char *)cookie->mmbar) + regno); return *(uint16 *)(((char *)cookie->mmbar) + regno);
else else
return drv->pci->read_io_16(cookie->nambar + regno); return cookie->pci->read_io_16(cookie->nambar + regno);
} }
void void
ich_codec_write(audio_drv_t *drv, int regno, uint16 value) ich_codec_write(void *_cookie, int regno, uint16 value)
{ {
ichaudio_cookie *cookie = (ichaudio_cookie *)drv->cookie; ichaudio_cookie *cookie = (ichaudio_cookie *)_cookie;
ASSERT(regno >= 0); ASSERT(regno >= 0);
ASSERT((regno & 1) == 0); ASSERT((regno & 1) == 0);
ASSERT(((drv->flags & TYPE_ICH4) != 0 && regno <= 511) || regno <= 255); ASSERT(((cookie->flags & TYPE_ICH4) != 0 && regno <= 511) || regno <= 255);
if (regno == 0x54) // intel uses 0x54 for GPIO access, we filter it! if (regno == 0x54) // intel uses 0x54 for GPIO access, we filter it!
return; return;
if (B_OK != ich_codec_wait(drv)) if (B_OK != ich_codec_wait(cookie))
PRINT(("semaphore timeout writing register %#x\n", regno)); PRINT(("semaphore timeout writing register %#x\n", regno));
if (drv->flags & TYPE_ICH4) if (cookie->flags & TYPE_ICH4)
*(uint16 *)(((char *)cookie->mmbar) + regno) = value; *(uint16 *)(((char *)cookie->mmbar) + regno) = value;
else else
drv->pci->write_io_16(cookie->nambar + regno, value); cookie->pci->write_io_16(cookie->nambar + regno, value);
} }
src/add-ons/kernel/drivers/audio/ac97/ichaudio/io.h
+8 -8
View File
@@ -30,15 +30,15 @@
#include "lala/lala.h" #include "lala/lala.h"
uint8 ich_reg_read_8(audio_drv_t *drv, int regno); uint8 ich_reg_read_8(ichaudio_cookie *cookie, int regno);
uint16 ich_reg_read_16(audio_drv_t *drv, int regno); uint16 ich_reg_read_16(ichaudio_cookie *cookie, int regno);
uint32 ich_reg_read_32(audio_drv_t *drv, int regno); uint32 ich_reg_read_32(ichaudio_cookie *cookie, int regno);
void ich_reg_write_8(audio_drv_t *drv, int regno, uint8 value); void ich_reg_write_8(ichaudio_cookie *cookie, int regno, uint8 value);
void ich_reg_write_16(audio_drv_t *drv, int regno, uint16 value); void ich_reg_write_16(ichaudio_cookie *cookie, int regno, uint16 value);
void ich_reg_write_32(audio_drv_t *drv, int regno, uint32 value); void ich_reg_write_32(ichaudio_cookie *cookie, int regno, uint32 value);
uint16 ich_codec_read(audio_drv_t *drv, int regno); uint16 ich_codec_read(void *_cookie, int regno);
void ich_codec_write(audio_drv_t *drv, int regno, uint16 value); void ich_codec_write(void *_cookie, int regno, uint16 value);
#endif #endif
src/add-ons/kernel/drivers/audio/ac97/ichaudio/lala/driver.c
+22 -22
View File
@@ -16,10 +16,13 @@ int32 api_version = B_CUR_DRIVER_API_VERSION;
sem_id drv_sem; sem_id drv_sem;
char * drv_path[MAX_DEVICES + 1]; char * drv_path[MAX_DEVICES + 1];
audio_drv_t * drv_data[MAX_DEVICES]; audio_drv_t * drv_data[MAX_DEVICES];
int drv_open_count[MAX_DEVICES];
void * drv_cookie[MAX_DEVICES];
int drv_count; int drv_count;
pci_module_info *pcimodule; pci_module_info *pcimodule;
extern driver_info_t driver_info;
status_t status_t
init_hardware(void) init_hardware(void)
@@ -53,25 +56,25 @@ init_driver(void)
// pciinfo->vendor_id, pciinfo->device_id, pciinfo->bus, pciinfo->device, pciinfo->function, // pciinfo->vendor_id, pciinfo->device_id, pciinfo->bus, pciinfo->device, pciinfo->function,
// pciinfo->revision, pciinfo->class_api, pciinfo->class_sub, pciinfo->class_base); // pciinfo->revision, pciinfo->class_api, pciinfo->class_sub, pciinfo->class_base);
for (devindex = 0; driver_info.table[devindex].vendor != 0; devindex++) { for (devindex = 0; driver_info.id_table[devindex].vendor != 0; devindex++) {
if (driver_info.table[devindex].vendor != -1 && driver_info.table[devindex].vendor != pciinfo->vendor_id) if (driver_info.id_table[devindex].vendor != -1 && driver_info.id_table[devindex].vendor != pciinfo->vendor_id)
continue; continue;
if (driver_info.table[devindex].device != -1 && driver_info.table[devindex].device != pciinfo->device_id) if (driver_info.id_table[devindex].device != -1 && driver_info.id_table[devindex].device != pciinfo->device_id)
continue; continue;
if (driver_info.table[devindex].revision != -1 && driver_info.table[devindex].revision != pciinfo->revision) if (driver_info.id_table[devindex].revision != -1 && driver_info.id_table[devindex].revision != pciinfo->revision)
continue; continue;
if (driver_info.table[devindex].class != -1 && driver_info.table[devindex].class != pciinfo->class_base) if (driver_info.id_table[devindex].class != -1 && driver_info.id_table[devindex].class != pciinfo->class_base)
continue; continue;
if (driver_info.table[devindex].subclass != -1 && driver_info.table[devindex].subclass != pciinfo->class_sub) if (driver_info.id_table[devindex].subclass != -1 && driver_info.id_table[devindex].subclass != pciinfo->class_sub)
continue; continue;
if (pciinfo->header_type == 0) { if (pciinfo->header_type == 0) {
if (driver_info.table[devindex].subsystem_vendor != -1 && driver_info.table[devindex].subsystem_vendor != pciinfo->u.h0.subsystem_vendor_id) if (driver_info.id_table[devindex].subsystem_vendor != -1 && driver_info.id_table[devindex].subsystem_vendor != pciinfo->u.h0.subsystem_vendor_id)
continue; continue;
if (driver_info.table[devindex].subsystem_device != -1 && driver_info.table[devindex].subsystem_device != pciinfo->u.h0.subsystem_id) if (driver_info.id_table[devindex].subsystem_device != -1 && driver_info.id_table[devindex].subsystem_device != pciinfo->u.h0.subsystem_id)
continue; continue;
} }
dprintf("found device '%s'\n", driver_info.table[devindex].name); dprintf("found device '%s'\n", driver_info.id_table[devindex].name);
drv_path[drv_count] = (char *) malloc(strlen(driver_info.basename) + 5); drv_path[drv_count] = (char *) malloc(strlen(driver_info.basename) + 5);
sprintf(drv_path[drv_count], "%s/%d", driver_info.basename, drv_count + 1); sprintf(drv_path[drv_count], "%s/%d", driver_info.basename, drv_count + 1);
@@ -81,10 +84,9 @@ init_driver(void)
drv_data[drv_count]->bus = pciinfo->bus; drv_data[drv_count]->bus = pciinfo->bus;
drv_data[drv_count]->device = pciinfo->device; drv_data[drv_count]->device = pciinfo->device;
drv_data[drv_count]->function = pciinfo->function; drv_data[drv_count]->function = pciinfo->function;
drv_data[drv_count]->name = driver_info.table[devindex].name; drv_data[drv_count]->name = driver_info.id_table[devindex].name;
drv_data[drv_count]->flags = driver_info.table[devindex].flags; drv_data[drv_count]->param = driver_info.id_table[devindex].param;
drv_data[drv_count]->open_count = 0; drv_open_count[drv_count] = 0;
drv_data[drv_count]->cookie = malloc(driver_info.cookie_size);
drv_count++; drv_count++;
break; break;
@@ -106,7 +108,6 @@ uninit_driver(void)
for (i = 0; i < drv_count; i++) { for (i = 0; i < drv_count; i++) {
free(drv_path[i]); free(drv_path[i]);
free(drv_data[i]->cookie);
free(drv_data[i]); free(drv_data[i]);
} }
delete_sem(drv_sem); delete_sem(drv_sem);
@@ -130,13 +131,12 @@ ich_open(const char *name, uint32 flags, void** cookie)
} }
*cookie = (void *) index; *cookie = (void *) index;
if (drv_data[index]->open_count == 0) { if (drv_open_count[index] == 0) {
memset(drv_data[index]->cookie, 0, driver_info.cookie_size); res = driver_info.attach(drv_data[index], &drv_cookie[index]);
res = driver_info.attach(drv_data[index]); drv_open_count[index] = (res == B_OK) ? 1 : 0;
drv_data[index]->open_count = (res == B_OK) ? 1 : 0;
} else { } else {
res = B_OK; res = B_OK;
drv_data[index]->open_count++; drv_open_count[index]++;
} }
release_sem(drv_sem); release_sem(drv_sem);
@@ -163,10 +163,10 @@ ich_free(void* cookie)
acquire_sem(drv_sem); acquire_sem(drv_sem);
drv_data[index]->open_count--; drv_open_count[index]--;
if (drv_data[index]->open_count == 0) if (drv_open_count[index] == 0)
res = driver_info.detach(drv_data[index]); res = driver_info.detach(drv_data[index], drv_cookie[index]);
else else
res = B_OK; res = B_OK;
src/add-ons/kernel/drivers/audio/ac97/ichaudio/lala/lala.h
+56 -48
View File
@@ -16,40 +16,36 @@ typedef struct
uint8 function; uint8 function;
const char * name; const char * name;
uint32 flags; void * param;
void * cookie;
// private:
int32 open_count;
} audio_drv_t; } audio_drv_t;
typedef void stream_id; typedef struct
typedef void control_id; {
int32 vendor;
typedef struct { int32 device;
int32 vendor; int32 revision;
int32 device; int32 class;
int32 revision; int32 subclass;
int32 class; int32 subsystem_vendor;
int32 subclass; int32 subsystem_device;
int32 subsystem_vendor; const char * name;
int32 subsystem_device; void * param;
const char *name;
uint32 flags;
} id_table_t; } id_table_t;
typedef status_t (*drv_attach) (audio_drv_t *drv); typedef int32 stream_id;
typedef status_t (*drv_powerctl) (audio_drv_t *drv); typedef int32 control_id;
typedef status_t (*drv_detach) (audio_drv_t *drv);
typedef status_t (*drv_attach) (audio_drv_t *drv, void **cookie);
typedef status_t (*drv_powerctl) (audio_drv_t *drv, void *cookie);
typedef status_t (*drv_detach) (audio_drv_t *drv, void *cookie);
typedef struct typedef struct
{ {
id_table_t * table; id_table_t * id_table;
const char * basename; const char * basename;
size_t cookie_size;
uint32 _reserved1[16]; uint32 _reserved1[16];
@@ -61,69 +57,81 @@ typedef struct
} driver_info_t; } driver_info_t;
typedef struct { typedef struct
{
char * base; /* pointer to first sample for channel for buffer */ char * base; /* pointer to first sample for channel for buffer */
size_t stride; /* offset to next sample */ size_t stride; /* offset to next sample */
uint32 _reserved[4]; uint32 _reserved[4];
} stream_buffer_desc_t; } stream_buffer_desc_t;
typedef struct { typedef status_t (*stream_attach) (audio_drv_t *drv, void **cookie, void *param);
uint32 frame_rate; typedef status_t (*stream_detach) (audio_drv_t *drv, void *cookie);
uint32 buffer_size; typedef status_t (*stream_control) (audio_drv_t *drv, void *cookie, int op);
uint32 _reserved[16]; typedef status_t (*stream_process) (audio_drv_t *drv, void *cookie, int buffer);
} stream_config_t; typedef status_t (*stream_set_buffers) (audio_drv_t *drv, void *cookie, uint32 *buffer_size, stream_buffer_desc_t *desc);
typedef status_t (*stream_set_frame_rate) (audio_drv_t *drv, void *cookie, uint32 *frame_rate);
enum {
B_RECORDING_STREAM = 0x00000001,
B_PLAYBACK_STREAM = 0x00000002,
B_BUFFER_SIZE_LINEAR = 0x00001000,
B_BUFFER_SIZE_EXPONETIAL = 0x00002000,
B_SAMPLE_TYPE_INT16 = 0x00010000,
B_SAMPLE_TYPE_INT32 = 0x00020000,
B_SAMPLE_TYPE_FLOAT32 = 0x00040000,
};
typedef status_t (*stream_attach) (audio_drv_t *drv, void *stream_cookie); enum {
typedef status_t (*stream_detach) (audio_drv_t *drv, void *stream_cookie); B_CHANNEL_LEFT = 0x0001,
typedef status_t (*stream_control) (audio_drv_t *drv, void *stream_cookie, int op); B_CHANNEL_RIGHT = 0x0002,
typedef status_t (*stream_get_buffer_info) (audio_drv_t *drv, void *stream_cookie, stream_buffer_desc_t *desc); };
typedef status_t (*stream_set_config) (audio_drv_t *drv, void *stream_cookie, stream_config_t *config);
enum {
B_FRAME_RATE_32000 = 0x0100,
B_FRAME_RATE_44100 = 0x0200,
B_FRAME_RATE_48000 = 0x0400,
B_FRAME_RATE_96000 = 0x0800,
B_FRAME_RATE_VARIABLE = 0x20000000,
};
typedef struct typedef struct
{ {
uint32 flags; uint32 flags;
uint32 cookie_size; uint32 cookie_size;
uint32 user_param;
uint32 user_cookie;
uint32 sample_bits; uint32 sample_bits;
uint32 sample_flags;
uint32 channel_count; uint32 channel_count;
uint32 channel_flags; uint32 channel_mask;
uint32 frame_rate_min; uint32 frame_rate_min;
uint32 frame_rate_max; uint32 frame_rate_max;
uint32 frame_rate_flags; uint32 frame_rate_mask;
uint32 buffer_size_min; uint32 buffer_size_min;
uint32 buffer_size_max; uint32 buffer_size_max;
uint32 buffer_size_flags; uint32 buffer_count;
uint32 _reserved1[32]; uint32 _reserved1[32];
stream_attach attach; stream_attach attach;
stream_detach detach; stream_detach detach;
stream_control control; stream_control control;
stream_process process;
stream_get_buffer_info get_buffer_info; stream_set_buffers set_buffers;
stream_set_frame_rate set_frame_rate;
stream_set_config set_config;
uint32 _reserved2[16]; uint32 _reserved2[16];
} stream_info_t; } stream_info_t;
extern driver_info_t driver_info;
// protection is 0 for kernel only access, or B_READ_AREA, B_WRITE_AREA for user space access // protection is 0 for kernel only access, or B_READ_AREA, B_WRITE_AREA for user space access
area_id alloc_mem(void **virt, void **phy, size_t size, uint32 protection, const char *name); area_id alloc_mem(void **virt, void **phy, size_t size, uint32 protection, const char *name);
area_id map_mem(void **virt, void *phy, size_t size, uint32 protection, const char *name); area_id map_mem(void **virt, void *phy, size_t size, uint32 protection, const char *name);
stream_id create_stream(audio_drv_t *dev, stream_info_t *info, void *config); stream_id create_stream(stream_info_t *info, void *param);
status_t delete_stream(stream_id stream); status_t delete_stream(stream_id stream);
void report_stream_event(stream_id stream, int ); void report_stream_buffer_ready(stream_id stream, int buffer, bigtime_t end_time, int64 total_frames);
control_id create_control_group(control_id parent, audio_drv_t *dev); control_id create_control_group(control_id parent, audio_drv_t *dev);
control_id create_control(control_id parent, uint32 flags, void *get, void *set, const char *name); control_id create_control(control_id parent, uint32 flags, void *get, void *set, const char *name);