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

Internal routing management for ice1712 audio driver

Browse Source 
* internal chip routing management.
* style cleanup.
This commit is contained in:
Jerome Leveque
2011-11-18 19:20:25 +01:00
committed by Jérôme Duval
parent 8a5fb91c07
commit 8519dc0f22
6 changed files with 232 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/drivers/audio/ice1712/ice1712.c
+98 -44
View File
@@ -9,6 +9,7 @@
* Distributed under the terms of the MIT license. * Distributed under the terms of the MIT license.
*/ */
#include <KernelExport.h> #include <KernelExport.h>
#include <Drivers.h> #include <Drivers.h>
#include <Errors.h> #include <Errors.h>
@@ -67,7 +68,8 @@ int32 api_version = B_CUR_DRIVER_API_VERSION;
//------------------------------------------------------ //------------------------------------------------------
//------------------------------------------------------ //------------------------------------------------------
status_t init_hardware(void) status_t
init_hardware(void)
{ {
int ix = 0; int ix = 0;
pci_info info; pci_info info;
@@ -137,6 +139,7 @@ ice1712_setup(ice1712 *ice)
int result, i; int result, i;
status_t status = B_OK; status_t status = B_OK;
uint8 reg8 = 0; uint8 reg8 = 0;
uint16 mute;
ice->irq = ice->info.u.h0.interrupt_line; ice->irq = ice->info.u.h0.interrupt_line;
ice->Controller = ice->info.u.h0.base_registers[0]; ice->Controller = ice->info.u.h0.base_registers[0];
@@ -161,36 +164,36 @@ ice1712_setup(ice1712 *ice)
//Write all configurations register from EEProm //Write all configurations register from EEProm
ice->info.device_id = ice->eeprom_data[E2PROM_MAP_SUBVENDOR_HIGH] << 8 ice->info.device_id = ice->eeprom_data[E2PROM_MAP_SUBVENDOR_HIGH] << 8
| ice->eeprom_data[E2PROM_MAP_SUBVENDOR_LOW]; | ice->eeprom_data[E2PROM_MAP_SUBVENDOR_LOW];
ice->info.vendor_id = ice->eeprom_data[E2PROM_MAP_SUBDEVICE_HIGH] << 8 ice->info.vendor_id = ice->eeprom_data[E2PROM_MAP_SUBDEVICE_HIGH] << 8
| ice->eeprom_data[E2PROM_MAP_SUBDEVICE_LOW]; | ice->eeprom_data[E2PROM_MAP_SUBDEVICE_LOW];
ice->product = ice->info.vendor_id << 16 | ice->info.device_id; ice->product = ice->info.vendor_id << 16 | ice->info.device_id;
TRACE("Product ID : 0x%x\n", ice->product); TRACE("Product ID : 0x%x\n", ice->product);
write_cci_uint8(ice, CCI_GPIO_WRITE_MASK, write_cci_uint8(ice, CCI_GPIO_WRITE_MASK,
ice->eeprom_data[E2PROM_MAP_GPIOMASK]); ice->eeprom_data[E2PROM_MAP_GPIOMASK]);
write_cci_uint8(ice, CCI_GPIO_DATA, write_cci_uint8(ice, CCI_GPIO_DATA,
ice->eeprom_data[E2PROM_MAP_GPIOSTATE]); ice->eeprom_data[E2PROM_MAP_GPIOSTATE]);
write_cci_uint8(ice, CCI_GPIO_DIRECTION_CONTROL, write_cci_uint8(ice, CCI_GPIO_DIRECTION_CONTROL,
ice->eeprom_data[E2PROM_MAP_GPIODIR]); ice->eeprom_data[E2PROM_MAP_GPIODIR]);
TRACE("CCI_GPIO_WRITE_MASK : 0x%x\n", TRACE("CCI_GPIO_WRITE_MASK : 0x%x\n",
ice->eeprom_data[E2PROM_MAP_GPIOMASK]); ice->eeprom_data[E2PROM_MAP_GPIOMASK]);
TRACE("CCI_GPIO_DATA : 0x%x\n", TRACE("CCI_GPIO_DATA : 0x%x\n",
ice->eeprom_data[E2PROM_MAP_GPIOSTATE]); ice->eeprom_data[E2PROM_MAP_GPIOSTATE]);
TRACE("CCI_GPIO_DIRECTION_CONTROL : 0x%x\n", TRACE("CCI_GPIO_DIRECTION_CONTROL : 0x%x\n",
ice->eeprom_data[E2PROM_MAP_GPIODIR]); ice->eeprom_data[E2PROM_MAP_GPIODIR]);
//Write Configuration in the PCI configuration Register //Write Configuration in the PCI configuration Register
(pci->write_pci_config)(ice->info.bus, ice->info.device, (pci->write_pci_config)(ice->info.bus, ice->info.device,
ice->info.function, 0x60, 1, ice->eeprom_data[E2PROM_MAP_CONFIG]); ice->info.function, 0x60, 1, ice->eeprom_data[E2PROM_MAP_CONFIG]);
(pci->write_pci_config)(ice->info.bus, ice->info.device, (pci->write_pci_config)(ice->info.bus, ice->info.device,
ice->info.function, 0x61, 1, ice->eeprom_data[E2PROM_MAP_ACL]); ice->info.function, 0x61, 1, ice->eeprom_data[E2PROM_MAP_ACL]);
(pci->write_pci_config)(ice->info.bus, ice->info.device, (pci->write_pci_config)(ice->info.bus, ice->info.device,
ice->info.function, 0x62, 1, ice->eeprom_data[E2PROM_MAP_I2S]); ice->info.function, 0x62, 1, ice->eeprom_data[E2PROM_MAP_I2S]);
(pci->write_pci_config)(ice->info.bus, ice->info.device, (pci->write_pci_config)(ice->info.bus, ice->info.device,
ice->info.function, 0x63, 1, ice->eeprom_data[E2PROM_MAP_SPDIF]); ice->info.function, 0x63, 1, ice->eeprom_data[E2PROM_MAP_SPDIF]);
TRACE("E2PROM_MAP_CONFIG : 0x%x\n", ice->eeprom_data[E2PROM_MAP_CONFIG]); TRACE("E2PROM_MAP_CONFIG : 0x%x\n", ice->eeprom_data[E2PROM_MAP_CONFIG]);
reg8 = ice->eeprom_data[E2PROM_MAP_CONFIG]; reg8 = ice->eeprom_data[E2PROM_MAP_CONFIG];
@@ -224,7 +227,7 @@ ice1712_setup(ice1712 *ice)
for (i = 0; i < ice->nb_MPU401; i++) { for (i = 0; i < ice->nb_MPU401; i++) {
sprintf(ice->midi_interf[i].name, "midi/ice1712/%ld/%d", sprintf(ice->midi_interf[i].name, "midi/ice1712/%ld/%d",
ice - cards + 1, i + 1); ice - cards + 1, i + 1);
names[num_names++] = ice->midi_interf[i].name; names[num_names++] = ice->midi_interf[i].name;
} }
@@ -238,7 +241,7 @@ ice1712_setup(ice1712 *ice)
ice->CommLines.data_in = 0; ice->CommLines.data_in = 0;
ice->CommLines.data_out = DELTA66_DOUT; ice->CommLines.data_out = DELTA66_DOUT;
ice->CommLines.cs_mask = DELTA66_CLK | DELTA66_DOUT ice->CommLines.cs_mask = DELTA66_CLK | DELTA66_DOUT
| DELTA66_CODEC_CS_0 | DELTA66_CODEC_CS_1; | DELTA66_CODEC_CS_0 | DELTA66_CODEC_CS_1;
break; break;
case ICE1712_SUBDEVICE_DELTA410 : case ICE1712_SUBDEVICE_DELTA410 :
case ICE1712_SUBDEVICE_AUDIOPHILE_2496 : case ICE1712_SUBDEVICE_AUDIOPHILE_2496 :
@@ -247,7 +250,7 @@ ice1712_setup(ice1712 *ice)
ice->CommLines.data_in = AP2496_DIN; ice->CommLines.data_in = AP2496_DIN;
ice->CommLines.data_out = AP2496_DOUT; ice->CommLines.data_out = AP2496_DOUT;
ice->CommLines.cs_mask = AP2496_CLK | AP2496_DIN ice->CommLines.cs_mask = AP2496_CLK | AP2496_DIN
| AP2496_DOUT | AP2496_SPDIF_CS | AP2496_CODEC_CS; | AP2496_DOUT | AP2496_SPDIF_CS | AP2496_CODEC_CS;
break; break;
case ICE1712_SUBDEVICE_DELTA1010 : case ICE1712_SUBDEVICE_DELTA1010 :
case ICE1712_SUBDEVICE_DELTA1010LT : case ICE1712_SUBDEVICE_DELTA1010LT :
@@ -255,14 +258,14 @@ ice1712_setup(ice1712 *ice)
ice->CommLines.data_in = DELTA1010LT_DIN; ice->CommLines.data_in = DELTA1010LT_DIN;
ice->CommLines.data_out = DELTA1010LT_DOUT; ice->CommLines.data_out = DELTA1010LT_DOUT;
ice->CommLines.cs_mask = DELTA1010LT_CLK | DELTA1010LT_DIN ice->CommLines.cs_mask = DELTA1010LT_CLK | DELTA1010LT_DIN
| DELTA1010LT_DOUT | DELTA1010LT_CS_NONE; | DELTA1010LT_DOUT | DELTA1010LT_CS_NONE;
break; break;
case ICE1712_SUBDEVICE_VX442 : case ICE1712_SUBDEVICE_VX442 :
ice->CommLines.clock = VX442_CLK; ice->CommLines.clock = VX442_CLK;
ice->CommLines.data_in = VX442_DIN; ice->CommLines.data_in = VX442_DIN;
ice->CommLines.data_out = VX442_DOUT; ice->CommLines.data_out = VX442_DOUT;
ice->CommLines.cs_mask = VX442_SPDIF_CS | VX442_CODEC_CS_0 ice->CommLines.cs_mask = VX442_SPDIF_CS | VX442_CODEC_CS_0
| VX442_CODEC_CS_1; | VX442_CODEC_CS_1;
break; break;
} }
@@ -325,9 +328,10 @@ ice1712_setup(ice1712 *ice)
//Set the rampe volume to a faster one //Set the rampe volume to a faster one
write_mt_uint16(ice, MT_VOLUME_CONTROL_RATE, 0x01); write_mt_uint16(ice, MT_VOLUME_CONTROL_RATE, 0x01);
//Digital Mixer To DAC 0 and SPDIF Out //All Analog outputs from DMA
write_mt_uint16(ice, MT_ROUTING_CONTROL_PSDOUT, 0x0101); write_mt_uint16(ice, MT_ROUTING_CONTROL_PSDOUT, 0x0000);
// write_mt_uint16(ice, MT_ROUTING_CONTROL_SPDOUT, 0x0005); //All Digital output from DMA
write_mt_uint16(ice, MT_ROUTING_CONTROL_SPDOUT, 0x0000);
//Just to route all input to all output //Just to route all input to all output
// write_mt_uint16(ice, MT_ROUTING_CONTROL_PSDOUT, 0xAAAA); // write_mt_uint16(ice, MT_ROUTING_CONTROL_PSDOUT, 0xAAAA);
@@ -338,12 +342,12 @@ ice1712_setup(ice1712 *ice)
// write_mt_uint32(ice, MT_CAPTURED_DATA, 0x76543280); // write_mt_uint32(ice, MT_CAPTURED_DATA, 0x76543280);
//Mute all input //Mute all input
/* for (i = 0; i < 20; i++) mute = (ICE1712_MUTE_VALUE << 0) | (ICE1712_MUTE_VALUE << 8);
{ for (i = 0; i < 2 * MAX_HARDWARE_VOLUME; i++) {
write_mt_uint8(ice, MT_VOLUME_CONTROL_CHANNEL_INDEX, i); write_mt_uint8(ice, MT_VOLUME_CONTROL_CHANNEL_INDEX, i);
write_mt_uint16(ice, MT_VOLUME_CONTROL_CHANNEL_INDEX, 0x7F7F); write_mt_uint16(ice, MT_VOLUME_CONTROL_CHANNEL_INDEX, mute);
} }
*/
//Unmask Interrupt //Unmask Interrupt
write_ccs_uint8(ice, CCS_CONTROL_STATUS, 0x41); write_ccs_uint8(ice, CCS_CONTROL_STATUS, 0x41);
@@ -529,7 +533,7 @@ ice_1712_control(void *cookie, uint32 op, void *arg, size_t len)
case B_MULTI_GET_DESCRIPTION : case B_MULTI_GET_DESCRIPTION :
TRACE("B_MULTI_GET_DESCRIPTION\n"); TRACE("B_MULTI_GET_DESCRIPTION\n");
return ice1712_get_description((ice1712 *)cookie, return ice1712_get_description((ice1712 *)cookie,
(multi_description*)arg); (multi_description*)arg);
case B_MULTI_GET_EVENT_INFO : case B_MULTI_GET_EVENT_INFO :
TRACE("B_MULTI_GET_EVENT_INFO\n"); TRACE("B_MULTI_GET_EVENT_INFO\n");
return B_ERROR; return B_ERROR;
@@ -542,19 +546,19 @@ ice_1712_control(void *cookie, uint32 op, void *arg, size_t len)
case B_MULTI_GET_ENABLED_CHANNELS : case B_MULTI_GET_ENABLED_CHANNELS :
TRACE("B_MULTI_GET_ENABLED_CHANNELS\n"); TRACE("B_MULTI_GET_ENABLED_CHANNELS\n");
return ice1712_get_enabled_channels((ice1712*)cookie, return ice1712_get_enabled_channels((ice1712*)cookie,
(multi_channel_enable*)arg); (multi_channel_enable*)arg);
case B_MULTI_SET_ENABLED_CHANNELS : case B_MULTI_SET_ENABLED_CHANNELS :
TRACE("B_MULTI_SET_ENABLED_CHANNELS\n"); TRACE("B_MULTI_SET_ENABLED_CHANNELS\n");
return ice1712_set_enabled_channels((ice1712*)cookie, return ice1712_set_enabled_channels((ice1712*)cookie,
(multi_channel_enable*)arg); (multi_channel_enable*)arg);
case B_MULTI_GET_GLOBAL_FORMAT : case B_MULTI_GET_GLOBAL_FORMAT :
TRACE("B_MULTI_GET_GLOBAL_FORMAT\n"); TRACE("B_MULTI_GET_GLOBAL_FORMAT\n");
return ice1712_get_global_format((ice1712*)cookie, return ice1712_get_global_format((ice1712*)cookie,
(multi_format_info *)arg); (multi_format_info *)arg);
case B_MULTI_SET_GLOBAL_FORMAT : case B_MULTI_SET_GLOBAL_FORMAT :
TRACE("B_MULTI_SET_GLOBAL_FORMAT\n"); TRACE("B_MULTI_SET_GLOBAL_FORMAT\n");
return ice1712_set_global_format((ice1712*)cookie, return ice1712_set_global_format((ice1712*)cookie,
(multi_format_info *)arg); (multi_format_info *)arg);
case B_MULTI_GET_CHANNEL_FORMATS : case B_MULTI_GET_CHANNEL_FORMATS :
TRACE("B_MULTI_GET_CHANNEL_FORMATS\n"); TRACE("B_MULTI_GET_CHANNEL_FORMATS\n");
return B_ERROR; return B_ERROR;
@@ -564,27 +568,27 @@ ice_1712_control(void *cookie, uint32 op, void *arg, size_t len)
case B_MULTI_GET_MIX : case B_MULTI_GET_MIX :
TRACE("B_MULTI_GET_MIX\n"); TRACE("B_MULTI_GET_MIX\n");
return ice1712_get_mix((ice1712*)cookie, return ice1712_get_mix((ice1712*)cookie,
(multi_mix_value_info *)arg); (multi_mix_value_info *)arg);
case B_MULTI_SET_MIX : case B_MULTI_SET_MIX :
TRACE("B_MULTI_SET_MIX\n"); TRACE("B_MULTI_SET_MIX\n");
return ice1712_set_mix((ice1712*)cookie, return ice1712_set_mix((ice1712*)cookie,
(multi_mix_value_info *)arg); (multi_mix_value_info *)arg);
case B_MULTI_LIST_MIX_CHANNELS : case B_MULTI_LIST_MIX_CHANNELS :
TRACE("B_MULTI_LIST_MIX_CHANNELS\n"); TRACE("B_MULTI_LIST_MIX_CHANNELS\n");
return ice1712_list_mix_channels((ice1712*)cookie, return ice1712_list_mix_channels((ice1712*)cookie,
(multi_mix_channel_info *)arg); (multi_mix_channel_info *)arg);
case B_MULTI_LIST_MIX_CONTROLS : case B_MULTI_LIST_MIX_CONTROLS :
TRACE("B_MULTI_LIST_MIX_CONTROLS\n"); TRACE("B_MULTI_LIST_MIX_CONTROLS\n");
return ice1712_list_mix_controls((ice1712*)cookie, return ice1712_list_mix_controls((ice1712*)cookie,
(multi_mix_control_info *)arg); (multi_mix_control_info *)arg);
case B_MULTI_LIST_MIX_CONNECTIONS : case B_MULTI_LIST_MIX_CONNECTIONS :
TRACE("B_MULTI_LIST_MIX_CONNECTIONS\n"); TRACE("B_MULTI_LIST_MIX_CONNECTIONS\n");
return ice1712_list_mix_connections((ice1712*)cookie, return ice1712_list_mix_connections((ice1712*)cookie,
(multi_mix_connection_info *)arg); (multi_mix_connection_info *)arg);
case B_MULTI_GET_BUFFERS : case B_MULTI_GET_BUFFERS :
TRACE("B_MULTI_GET_BUFFERS\n"); TRACE("B_MULTI_GET_BUFFERS\n");
return ice1712_get_buffers((ice1712*)cookie, return ice1712_get_buffers((ice1712*)cookie,
(multi_buffer_list*)arg); (multi_buffer_list*)arg);
case B_MULTI_SET_BUFFERS : case B_MULTI_SET_BUFFERS :
TRACE("B_MULTI_SET_BUFFERS\n"); TRACE("B_MULTI_SET_BUFFERS\n");
return B_ERROR; return B_ERROR;
@@ -594,7 +598,7 @@ ice_1712_control(void *cookie, uint32 op, void *arg, size_t len)
case B_MULTI_BUFFER_EXCHANGE : case B_MULTI_BUFFER_EXCHANGE :
// TRACE("B_MULTI_BUFFER_EXCHANGE\n"); // TRACE("B_MULTI_BUFFER_EXCHANGE\n");
return ice1712_buffer_exchange((ice1712*)cookie, return ice1712_buffer_exchange((ice1712*)cookie,
(multi_buffer_info *)arg); (multi_buffer_info *)arg);
case B_MULTI_BUFFER_FORCE_STOP : case B_MULTI_BUFFER_FORCE_STOP :
TRACE("B_MULTI_BUFFER_FORCE_STOP\n"); TRACE("B_MULTI_BUFFER_FORCE_STOP\n");
return ice1712_buffer_force_stop((ice1712*)cookie); return ice1712_buffer_force_stop((ice1712*)cookie);
@@ -635,7 +639,7 @@ ice_1712_read(void *cookie, off_t position, void *buf, size_t *num_bytes)
static status_t static status_t
ice_1712_write(void *cookie, off_t position, const void *buffer, ice_1712_write(void *cookie, off_t position, const void *buffer,
size_t *num_bytes) size_t *num_bytes)
{ {
TRACE("===write()===\n"); TRACE("===write()===\n");
*num_bytes = 0; *num_bytes = 0;
@@ -680,7 +684,7 @@ find_device(const char * name)
TRACE("ice1712: find_device(%s)\n", name); TRACE("ice1712: find_device(%s)\n", name);
for (ix=0; ix<num_cards; ix++) { for (ix=0; ix < num_cards; ix++) {
/* if (!strcmp(cards[ix].midi.name, name)) { /* if (!strcmp(cards[ix].midi.name, name)) {
return &midi_hooks; return &midi_hooks;
@@ -696,13 +700,12 @@ find_device(const char * name)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#define ICE1712_MUTE_VALUE (0x7F)
status_t status_t
applySettings(ice1712 *card) applySettings(ice1712 *card)
{ {
int i; int i;
uint16 val; uint16 val, mt30 = 0;
uint32 mt34 = 0;
for (i = 0; i < MAX_HARDWARE_VOLUME; i++) { for (i = 0; i < MAX_HARDWARE_VOLUME; i++) {
//Select the channel //Select the channel
@@ -728,7 +731,7 @@ applySettings(ice1712 *card)
for (i = 0; i < MAX_HARDWARE_VOLUME; i++) { for (i = 0; i < MAX_HARDWARE_VOLUME; i++) {
//Select the channel //Select the channel
write_mt_uint8(card, MT_VOLUME_CONTROL_CHANNEL_INDEX, write_mt_uint8(card, MT_VOLUME_CONTROL_CHANNEL_INDEX,
i + MAX_HARDWARE_VOLUME); i + MAX_HARDWARE_VOLUME);
if (card->settings.Record[i].Mute == true) { if (card->settings.Record[i].Mute == true) {
val = (ICE1712_MUTE_VALUE << 0) | (ICE1712_MUTE_VALUE << 8); val = (ICE1712_MUTE_VALUE << 0) | (ICE1712_MUTE_VALUE << 8);
@@ -747,7 +750,58 @@ applySettings(ice1712 *card)
TRACE_VV("Apply Settings %d : 0x%x\n", i, val); TRACE_VV("Apply Settings %d : 0x%x\n", i, val);
} }
//Output selection //Analog output selection
for (i = 0; i < 4; i++) {
uint8 out = card->settings.Output[i];
if (out == 0) {
TRACE_VV("Output %d is haiku output\n", i);
//Nothing to do
} else if (out <= (card->nb_ADC / 2)) {
uint8 mt34_c;
out--;
TRACE_VV("Output %d is input %d\n", i, out);
mt34_c = (out * 2);
mt34_c |= (out * 2 + 1) << 4;
mt30 |= 0x0202 << (2*i);
mt30 |= mt34_c << (8*i);
} else if (out == ((card->nb_ADC / 2) + 1)
&& (card->spdif_config & YES_IN_NO_OUT) != 0) {
TRACE_VV("Output %d is digital input\n", i);
mt30 |= 0x0303 << (2*i);
mt34 |= 0x80 << (8*i);
} else {
TRACE_VV("Output %d is digital Mixer\n", i);
mt30 |= 0x0101;
}
}
write_mt_uint16(card, MT_ROUTING_CONTROL_PSDOUT, mt30);
write_mt_uint32(card, MT_CAPTURED_DATA, mt34);
//Digital output
if ((card->spdif_config & NO_IN_YES_OUT) != 0) {
uint16 mt32 = 0;
uint8 out = card->settings.Output[4];
if (out == 0) {
TRACE_VV("Digital output is haiku output\n");
//Nothing to do
} else if (out <= (card->nb_ADC / 2)) {
out--;
TRACE_VV("Digital output is input %d\n", out);
mt32 |= 0x0202;
mt32 |= (out * 2) << 8;
mt32 |= (out * 2 + 1) << 12;
} else if (out == ((card->nb_ADC / 2) + 1)
&& (card->spdif_config & YES_IN_NO_OUT) != 0) {
TRACE_VV("Digital output is digital input\n");
mt32 |= 0x800F;
} else {
TRACE_VV("Digital output is digital Mixer\n");
mt32 |= 0x0005;
}
write_mt_uint16(card, MT_ROUTING_CONTROL_SPDOUT, mt32);
}
return B_OK; return B_OK;
} }
src/add-ons/kernel/drivers/audio/ice1712/ice1712.h
+2 -1
View File
@@ -8,10 +8,10 @@
* All rights reserved * All rights reserved
* Distributed under the terms of the MIT license. * Distributed under the terms of the MIT license.
*/ */
#ifndef _ICE1712_H_ #ifndef _ICE1712_H_
#define _ICE1712_H_ #define _ICE1712_H_
#include <PCI.h> #include <PCI.h>
#include "hmulti_audio.h" #include "hmulti_audio.h"
@@ -41,6 +41,7 @@ typedef enum product_t {
#define MAX_BUFFER_FRAMES 2048 #define MAX_BUFFER_FRAMES 2048
#define MAX_HARDWARE_VOLUME 10 #define MAX_HARDWARE_VOLUME 10
#define ICE1712_MUTE_VALUE 0x7F
#define PLAYBACK_BUFFER_SIZE (MAX_BUFFER_FRAMES * MAX_DAC * SAMPLE_SIZE) #define PLAYBACK_BUFFER_SIZE (MAX_BUFFER_FRAMES * MAX_DAC * SAMPLE_SIZE)
#define RECORD_BUFFER_SIZE (MAX_BUFFER_FRAMES * MAX_ADC * SAMPLE_SIZE) #define RECORD_BUFFER_SIZE (MAX_BUFFER_FRAMES * MAX_ADC * SAMPLE_SIZE)
src/add-ons/kernel/drivers/audio/ice1712/io.c
+5 -5
View File
@@ -192,8 +192,8 @@ read_ds_channel_data(ice1712 *ice, uint8 channel, ds8_register index)
void void
write_ds_channel_data(ice1712 *ice, uint8 channel, write_ds_channel_data(ice1712 *ice, uint8 channel, ds8_register index,
ds8_register index, uint32 data) uint32 data)
{ {
uint8 ds8_channel_index = channel << 4 | index; uint8 ds8_channel_index = channel << 4 | index;
@@ -470,7 +470,7 @@ ak45xx_write_gpio(ice1712 *ice, uint8 reg_addr, uint8 data, uint8 chip_select)
snooze(GPIO_I2C_DELAY); snooze(GPIO_I2C_DELAY);
write_gpio_byte(ice, ((AK45xx_CHIP_ADDRESS & 0x03) << 6) | 0x20 write_gpio_byte(ice, ((AK45xx_CHIP_ADDRESS & 0x03) << 6) | 0x20
| (reg_addr & 0x1F), tmp); | (reg_addr & 0x1F), tmp);
write_gpio_byte(ice, data, tmp); write_gpio_byte(ice, data, tmp);
tmp |= chip_select; tmp |= chip_select;
@@ -512,7 +512,7 @@ cs84xx_read_gpio(ice1712 *ice, uint8 reg_addr, uint8 chip_select)
snooze(GPIO_I2C_DELAY); snooze(GPIO_I2C_DELAY);
write_gpio_byte(ice, (CS84xx_CHIP_ADDRESS & 0x7F) << 1, write_gpio_byte(ice, (CS84xx_CHIP_ADDRESS & 0x7F) << 1,
tmp); //For writing the MAP tmp); //For writing the MAP
write_gpio_byte(ice, reg_addr & 0x7F, tmp); //Do not Increment write_gpio_byte(ice, reg_addr & 0x7F, tmp); //Do not Increment
tmp |= chip_select; //Deselect the chip tmp |= chip_select; //Deselect the chip
@@ -524,7 +524,7 @@ cs84xx_read_gpio(ice1712 *ice, uint8 reg_addr, uint8 chip_select)
snooze(GPIO_I2C_DELAY); snooze(GPIO_I2C_DELAY);
write_gpio_byte(ice, (CS84xx_CHIP_ADDRESS & 0x7F) << 1 | 1, write_gpio_byte(ice, (CS84xx_CHIP_ADDRESS & 0x7F) << 1 | 1,
tmp); //For writing the MAP tmp); //For writing the MAP
data = read_gpio_byte(ice, tmp); //For reading data = read_gpio_byte(ice, tmp); //For reading
tmp |= chip_select; //Deselect the chip tmp |= chip_select; //Deselect the chip
src/add-ons/kernel/drivers/audio/ice1712/io.h
+1 -1
View File
@@ -63,7 +63,7 @@ typedef enum {
uint32 read_ds_channel_data(ice1712 *ice, uint8 channel, ds8_register index); uint32 read_ds_channel_data(ice1712 *ice, uint8 channel, ds8_register index);
void write_ds_channel_data(ice1712 *ice, uint8 channel, void write_ds_channel_data(ice1712 *ice, uint8 channel,
ds8_register index, uint32 data); ds8_register index, uint32 data);
//------------------------------------------------------ //------------------------------------------------------
//------------------------------------------------------ //------------------------------------------------------
//Address are [PCI_1C] + xx //Address are [PCI_1C] + xx
src/add-ons/kernel/drivers/audio/ice1712/multi.c
+115 -99
View File
@@ -9,6 +9,7 @@
* Distributed under the terms of the MIT license. * Distributed under the terms of the MIT license.
*/ */
#include "ice1712_reg.h" #include "ice1712_reg.h"
#include "io.h" #include "io.h"
#include "multi.h" #include "multi.h"
@@ -24,6 +25,7 @@
#define MAX_CONTROL 32 #define MAX_CONTROL 32
static void static void
start_DMA(ice1712 *card) start_DMA(ice1712 *card)
{ {
@@ -32,9 +34,9 @@ start_DMA(ice1712 *card)
write_mt_uint8(card, MT_PROF_PB_CONTROL, 0); write_mt_uint8(card, MT_PROF_PB_CONTROL, 0);
write_mt_uint32(card, MT_PROF_PB_DMA_BASE_ADDRESS, write_mt_uint32(card, MT_PROF_PB_DMA_BASE_ADDRESS,
(uint32)card->phys_addr_pb); (uint32)card->phys_addr_pb);
write_mt_uint16(card, MT_PROF_PB_DMA_COUNT_ADDRESS, write_mt_uint16(card, MT_PROF_PB_DMA_COUNT_ADDRESS,
(size * SWAPPING_BUFFERS) - 1); (size * SWAPPING_BUFFERS) - 1);
//We want interrupt only from playback //We want interrupt only from playback
write_mt_uint16(card, MT_PROF_PB_DMA_TERM_COUNT, size - 1); write_mt_uint16(card, MT_PROF_PB_DMA_TERM_COUNT, size - 1);
TRACE("SIZE DMA PLAYBACK %#x\n", size); TRACE("SIZE DMA PLAYBACK %#x\n", size);
@@ -42,9 +44,9 @@ start_DMA(ice1712 *card)
size = card->buffer_size * MAX_ADC; size = card->buffer_size * MAX_ADC;
write_mt_uint32(card, MT_PROF_REC_DMA_BASE_ADDRESS, write_mt_uint32(card, MT_PROF_REC_DMA_BASE_ADDRESS,
(uint32)card->phys_addr_rec); (uint32)card->phys_addr_rec);
write_mt_uint16(card, MT_PROF_REC_DMA_COUNT_ADDRESS, write_mt_uint16(card, MT_PROF_REC_DMA_COUNT_ADDRESS,
(size * SWAPPING_BUFFERS) - 1); (size * SWAPPING_BUFFERS) - 1);
//We do not want any interrupt from the record //We do not want any interrupt from the record
write_mt_uint16(card, MT_PROF_REC_DMA_TERM_COUNT, 0); write_mt_uint16(card, MT_PROF_REC_DMA_TERM_COUNT, 0);
TRACE("SIZE DMA RECORD %#x\n", size); TRACE("SIZE DMA RECORD %#x\n", size);
@@ -103,6 +105,7 @@ start_DMA(ice1712 *card)
write_mt_uint8(card, MT_PROF_PB_CONTROL, 5); write_mt_uint8(card, MT_PROF_PB_CONTROL, 5);
} }
status_t status_t
ice1712_get_description(ice1712 *card, multi_description *data) ice1712_get_description(ice1712 *card, multi_description *data)
{ {
@@ -150,11 +153,9 @@ ice1712_get_description(ice1712 *card, multi_description *data)
data->input_bus_channel_count = 0; data->input_bus_channel_count = 0;
data->aux_bus_channel_count = 0; data->aux_bus_channel_count = 0;
size = data->output_channel_count + size = data->output_channel_count + data->input_channel_count
data->input_channel_count + + data->output_bus_channel_count + data->input_bus_channel_count
data->output_bus_channel_count + + data->aux_bus_channel_count;
data->input_bus_channel_count +
data->aux_bus_channel_count;
TRACE_VV("request_channel_count = %ld\n", data->request_channel_count); TRACE_VV("request_channel_count = %ld\n", data->request_channel_count);
@@ -190,7 +191,7 @@ ice1712_get_description(ice1712 *card, multi_description *data)
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS data->channels[chan].designations = B_CHANNEL_STEREO_BUS
| ((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT; | ((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT;
data->channels[chan].connectors = 0; data->channels[chan].connectors = 0;
chan++; chan++;
} }
@@ -200,13 +201,13 @@ ice1712_get_description(ice1712 *card, multi_description *data)
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS data->channels[chan].designations = B_CHANNEL_STEREO_BUS
| B_CHANNEL_LEFT; | B_CHANNEL_LEFT;
data->channels[chan].connectors = 0; data->channels[chan].connectors = 0;
chan++; chan++;
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS data->channels[chan].designations = B_CHANNEL_STEREO_BUS
| B_CHANNEL_RIGHT; | B_CHANNEL_RIGHT;
data->channels[chan].connectors = 0; data->channels[chan].connectors = 0;
chan++; chan++;
} }
@@ -215,13 +216,13 @@ ice1712_get_description(ice1712 *card, multi_description *data)
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS data->channels[chan].designations = B_CHANNEL_STEREO_BUS
| B_CHANNEL_LEFT; | B_CHANNEL_LEFT;
data->channels[chan].connectors = 0; data->channels[chan].connectors = 0;
chan++; chan++;
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS data->channels[chan].designations = B_CHANNEL_STEREO_BUS
| B_CHANNEL_RIGHT; | B_CHANNEL_RIGHT;
data->channels[chan].connectors = 0; data->channels[chan].connectors = 0;
chan++; chan++;
} }
@@ -232,13 +233,14 @@ ice1712_get_description(ice1712 *card, multi_description *data)
TRACE("input_bus_channel_count = %ld\n", data->input_bus_channel_count); TRACE("input_bus_channel_count = %ld\n", data->input_bus_channel_count);
data->output_rates = data->input_rates = AUTHORIZED_RATE; data->output_rates = data->input_rates = AUTHORIZED_RATE;
data->min_cvsr_rate = data->max_cvsr_rate = 0; data->min_cvsr_rate = 44100;
data->max_cvsr_rate = 96000;
data->output_formats = data->input_formats = AUTHORIZED_SAMPLE_SIZE; data->output_formats = data->input_formats = AUTHORIZED_SAMPLE_SIZE;
data->lock_sources = B_MULTI_LOCK_INTERNAL | B_MULTI_LOCK_SPDIF; data->lock_sources = B_MULTI_LOCK_INTERNAL | B_MULTI_LOCK_SPDIF;
data->timecode_sources = 0; data->timecode_sources = 0;
data->interface_flags = B_MULTI_INTERFACE_PLAYBACK data->interface_flags = B_MULTI_INTERFACE_PLAYBACK
| B_MULTI_INTERFACE_RECORD; | B_MULTI_INTERFACE_RECORD;
data->start_latency = 0; data->start_latency = 0;
strcpy(data->control_panel,""); strcpy(data->control_panel,"");
@@ -360,6 +362,7 @@ ice1712_set_global_format(ice1712 *card, multi_format_info *data)
return B_OK; return B_OK;
} }
static uint32 static uint32
get_combo_cb(ice1712 *card, uint32 index) get_combo_cb(ice1712 *card, uint32 index)
{ {
@@ -392,6 +395,7 @@ get_combo_cb(ice1712 *card, uint32 index)
return value; return value;
} }
static void static void
set_combo_cb(ice1712 *card, uint32 index, uint32 value) set_combo_cb(ice1712 *card, uint32 index, uint32 value)
{ {
@@ -429,6 +433,7 @@ set_combo_cb(ice1712 *card, uint32 index, uint32 value)
} }
} }
static uint32 static uint32
get_output_cb(ice1712 *card, uint32 index) get_output_cb(ice1712 *card, uint32 index)
{ {
@@ -442,6 +447,7 @@ get_output_cb(ice1712 *card, uint32 index)
return value; return value;
} }
static void static void
set_output_cb(ice1712 *card, uint32 index, uint32 value) set_output_cb(ice1712 *card, uint32 index, uint32 value)
{ {
@@ -451,6 +457,7 @@ set_output_cb(ice1712 *card, uint32 index, uint32 value)
TRACE_VV(" set_output_cb: %ld, %ld\n", index, value); TRACE_VV(" set_output_cb: %ld, %ld\n", index, value);
} }
static void static void
get_volume_cb(ice1712 *card, multi_mix_value *mmv) get_volume_cb(ice1712 *card, multi_mix_value *mmv)
{ {
@@ -471,8 +478,8 @@ get_volume_cb(ice1712 *card, multi_mix_value *mmv)
switch (ICE1712_MULTI_GET_INDEX(mmv->id)) { switch (ICE1712_MULTI_GET_INDEX(mmv->id)) {
case 0: //Mute case 0: //Mute
mmv->u.enable = vol[chan].Mute | vol[chan + 1].Mute; mmv->u.enable = vol[chan].Mute | vol[chan + 1].Mute;
TRACE_VV(" Get mute %d for channel %d or %d\n", TRACE_VV("\tGet mute %d for channel %d or %d\n",
mmv->u.enable, (int)chan, (int)chan + 1); mmv->u.enable, (int)chan, (int)chan + 1);
break; break;
case 2: //Right channel case 2: //Right channel
@@ -480,12 +487,13 @@ get_volume_cb(ice1712 *card, multi_mix_value *mmv)
//No break //No break
case 1: //Left channel case 1: //Left channel
mmv->u.gain = vol[chan].Volume; mmv->u.gain = vol[chan].Volume;
TRACE_VV(" Get Volume %f for channel %d\n", TRACE_VV("\tGet Volume %f for channel %d\n",
mmv->u.gain, (int)chan); mmv->u.gain, (int)chan);
break; break;
} }
} }
static void static void
set_volume_cb(ice1712 *card, multi_mix_value *mmv) set_volume_cb(ice1712 *card, multi_mix_value *mmv)
{ {
@@ -507,8 +515,8 @@ set_volume_cb(ice1712 *card, multi_mix_value *mmv)
case 0: //Mute case 0: //Mute
vol[chan].Mute = mmv->u.enable; vol[chan].Mute = mmv->u.enable;
vol[chan + 1].Mute = mmv->u.enable; vol[chan + 1].Mute = mmv->u.enable;
TRACE_VV(" Change mute to %d for channel %d and %d\n", TRACE_VV("\tChange mute to %d for channel %d and %d\n",
mmv->u.enable, (int)chan, (int)chan + 1); mmv->u.enable, (int)chan, (int)chan + 1);
break; break;
case 2: //Right channel case 2: //Right channel
@@ -516,12 +524,13 @@ set_volume_cb(ice1712 *card, multi_mix_value *mmv)
//No break //No break
case 1: //Left channel case 1: //Left channel
vol[chan].Volume = mmv->u.gain; vol[chan].Volume = mmv->u.gain;
TRACE_VV(" Change Volume to %f for channel %d\n", TRACE_VV("\tChange Volume to %f for channel %d\n",
mmv->u.gain, (int)chan); mmv->u.gain, (int)chan);
break; break;
} }
} }
status_t status_t
ice1712_get_mix(ice1712 *card, multi_mix_value_info *data) ice1712_get_mix(ice1712 *card, multi_mix_value_info *data)
{ {
@@ -534,7 +543,7 @@ ice1712_get_mix(ice1712 *card, multi_mix_value_info *data)
switch (mmv->id & ICE1712_MULTI_CONTROL_TYPE_MASK) { switch (mmv->id & ICE1712_MULTI_CONTROL_TYPE_MASK) {
case ICE1712_MULTI_CONTROL_TYPE_COMBO: case ICE1712_MULTI_CONTROL_TYPE_COMBO:
mmv->u.mux = get_combo_cb(card, mmv->u.mux = get_combo_cb(card,
ICE1712_MULTI_GET_CHANNEL(mmv->id)); ICE1712_MULTI_GET_CHANNEL(mmv->id));
break; break;
case ICE1712_MULTI_CONTROL_TYPE_VOLUME: case ICE1712_MULTI_CONTROL_TYPE_VOLUME:
@@ -543,7 +552,7 @@ ice1712_get_mix(ice1712 *card, multi_mix_value_info *data)
case ICE1712_MULTI_CONTROL_TYPE_OUTPUT: case ICE1712_MULTI_CONTROL_TYPE_OUTPUT:
mmv->u.mux = get_output_cb(card, mmv->u.mux = get_output_cb(card,
ICE1712_MULTI_GET_CHANNEL(mmv->id)); ICE1712_MULTI_GET_CHANNEL(mmv->id));
break; break;
default: default:
@@ -555,6 +564,7 @@ ice1712_get_mix(ice1712 *card, multi_mix_value_info *data)
return B_OK; return B_OK;
} }
status_t status_t
ice1712_set_mix(ice1712 *card, multi_mix_value_info *data) ice1712_set_mix(ice1712 *card, multi_mix_value_info *data)
{ {
@@ -568,7 +578,7 @@ ice1712_set_mix(ice1712 *card, multi_mix_value_info *data)
switch (mmv->id & ICE1712_MULTI_CONTROL_TYPE_MASK) { switch (mmv->id & ICE1712_MULTI_CONTROL_TYPE_MASK) {
case ICE1712_MULTI_CONTROL_TYPE_COMBO: case ICE1712_MULTI_CONTROL_TYPE_COMBO:
set_combo_cb(card, ICE1712_MULTI_GET_CHANNEL(mmv->id), set_combo_cb(card, ICE1712_MULTI_GET_CHANNEL(mmv->id),
mmv->u.mux); mmv->u.mux);
break; break;
case ICE1712_MULTI_CONTROL_TYPE_VOLUME: case ICE1712_MULTI_CONTROL_TYPE_VOLUME:
@@ -577,7 +587,7 @@ ice1712_set_mix(ice1712 *card, multi_mix_value_info *data)
case ICE1712_MULTI_CONTROL_TYPE_OUTPUT: case ICE1712_MULTI_CONTROL_TYPE_OUTPUT:
set_output_cb(card, ICE1712_MULTI_GET_CHANNEL(mmv->id), set_output_cb(card, ICE1712_MULTI_GET_CHANNEL(mmv->id),
mmv->u.mux); mmv->u.mux);
break; break;
default: default:
@@ -592,7 +602,8 @@ ice1712_set_mix(ice1712 *card, multi_mix_value_info *data)
status_t status_t
ice1712_list_mix_channels(ice1712 *card, multi_mix_channel_info *data) ice1712_list_mix_channels(ice1712 *card, multi_mix_channel_info *data)
{//Not Implemented {
//Not Implemented
return B_OK; return B_OK;
} }
@@ -682,6 +693,7 @@ static const char *string_list[] = {
static int32 nb_control_created; static int32 nb_control_created;
//This will create a Tab //This will create a Tab
static int32 static int32
create_group_control(multi_mix_control **p_mmc, int32 index, int32 parent, create_group_control(multi_mix_control **p_mmc, int32 index, int32 parent,
@@ -711,14 +723,15 @@ create_group_control(multi_mix_control **p_mmc, int32 index, int32 parent,
return group; return group;
} }
//This will create a Slider with a "Mute" CheckBox //This will create a Slider with a "Mute" CheckBox
static void static void
create_channel_control(multi_mix_control **p_mmc, int32 channel, int32 parent, create_channel_control(multi_mix_control **p_mmc, int32 channel, int32 parent,
const char* name) const char* name)
{ {
int32 id = ICE1712_MULTI_CONTROL_FIRSTID int32 id = ICE1712_MULTI_CONTROL_FIRSTID
+ ICE1712_MULTI_CONTROL_TYPE_VOLUME + ICE1712_MULTI_CONTROL_TYPE_VOLUME
+ ICE1712_MULTI_SET_CHANNEL(channel); + ICE1712_MULTI_SET_CHANNEL(channel);
multi_mix_control *mmc = *p_mmc; multi_mix_control *mmc = *p_mmc;
multi_mix_control control; multi_mix_control control;
@@ -762,13 +775,14 @@ create_channel_control(multi_mix_control **p_mmc, int32 channel, int32 parent,
(*p_mmc) = mmc; (*p_mmc) = mmc;
} }
static void static void
create_combo_control(multi_mix_control **p_mmc, const char *values[], create_combo_control(multi_mix_control **p_mmc, const char *values[],
int32 parent, int32 nb_combo, const char *name) int32 parent, int32 nb_combo, const char *name)
{ {
int32 id = ICE1712_MULTI_CONTROL_FIRSTID int32 id = ICE1712_MULTI_CONTROL_FIRSTID
+ ICE1712_MULTI_CONTROL_TYPE_COMBO + ICE1712_MULTI_CONTROL_TYPE_COMBO
+ ICE1712_MULTI_SET_CHANNEL(nb_combo); + ICE1712_MULTI_SET_CHANNEL(nb_combo);
multi_mix_control *mmc = *p_mmc; multi_mix_control *mmc = *p_mmc;
int32 parentControl, i; int32 parentControl, i;
@@ -799,15 +813,16 @@ create_combo_control(multi_mix_control **p_mmc, const char *values[],
(*p_mmc) = mmc; (*p_mmc) = mmc;
} }
//This will create all possible value for the output //This will create all possible value for the output
//output 0 -> 3 (physical stereo output) 4 is the Digital //output 0 -> 3 (physical stereo output) 4 is the Digital
static void static void
create_output_choice(ice1712 *card, multi_mix_control **p_mmc, create_output_choice(ice1712 *card, multi_mix_control **p_mmc,
int32 output, int32 parent) int32 output, int32 parent)
{ {
int32 id = ICE1712_MULTI_CONTROL_FIRSTID int32 id = ICE1712_MULTI_CONTROL_FIRSTID
+ ICE1712_MULTI_CONTROL_TYPE_OUTPUT + ICE1712_MULTI_CONTROL_TYPE_OUTPUT
+ ICE1712_MULTI_SET_CHANNEL(output); + ICE1712_MULTI_SET_CHANNEL(output);
multi_mix_control *mmc = *p_mmc; multi_mix_control *mmc = *p_mmc;
int32 parentControl, i; int32 parentControl, i;
@@ -871,6 +886,7 @@ create_output_choice(ice1712 *card, multi_mix_control **p_mmc,
(*p_mmc) = mmc; (*p_mmc) = mmc;
} }
status_t status_t
ice1712_list_mix_controls(ice1712 *card, multi_mix_control_info *mmci) ice1712_list_mix_controls(ice1712 *card, multi_mix_control_info *mmci)
{ {
@@ -887,27 +903,27 @@ ice1712_list_mix_controls(ice1712 *card, multi_mix_control_info *mmci)
//Setup tab //Setup tab
parentTab = create_group_control(&mmc, group++, parentTab = create_group_control(&mmc, group++,
CONTROL_IS_MASTER, S_SETUP, NULL); CONTROL_IS_MASTER, S_SETUP, NULL);
//General Settings //General Settings
parentTabColumn = create_group_control(&mmc, group++, parentTab, parentTabColumn = create_group_control(&mmc, group++, parentTab,
S_null, string_list[1]); S_null, string_list[1]);
for (i = 0; SettingsGeneral[i] != NULL; i++) { for (i = 0; SettingsGeneral[i] != NULL; i++) {
create_combo_control(&mmc, SettingsGeneral[i], parentTabColumn, create_combo_control(&mmc, SettingsGeneral[i], parentTabColumn,
combo++, string_list[5 + i]); combo++, string_list[5 + i]);
} }
//Digital Settings //Digital Settings
parentTabColumn = create_group_control(&mmc, group++, parentTab, parentTabColumn = create_group_control(&mmc, group++, parentTab,
S_null, string_list[2]); S_null, string_list[2]);
for (i = 0; SettingsDigital[i] != NULL; i++) { for (i = 0; SettingsDigital[i] != NULL; i++) {
create_combo_control(&mmc, SettingsDigital[i], parentTabColumn, create_combo_control(&mmc, SettingsDigital[i], parentTabColumn,
combo++, string_list[8 + i]); combo++, string_list[8 + i]);
} }
//Output Selection Settings //Output Selection Settings
parentTabColumn = create_group_control(&mmc, group++, parentTab, parentTabColumn = create_group_control(&mmc, group++, parentTab,
S_null, string_list[3]); S_null, string_list[3]);
for (i = 0; i < card->nb_DAC; i += 2) { for (i = 0; i < card->nb_DAC; i += 2) {
create_output_choice(card, &mmc, i / 2, parentTabColumn); create_output_choice(card, &mmc, i / 2, parentTabColumn);
} }
@@ -919,34 +935,34 @@ ice1712_list_mix_controls(ice1712 *card, multi_mix_control_info *mmci)
//Internal Mixer Tab //Internal Mixer Tab
//Output //Output
parentTab = create_group_control(&mmc, group++, CONTROL_IS_MASTER, parentTab = create_group_control(&mmc, group++, CONTROL_IS_MASTER,
S_null, string_list[4]); S_null, string_list[4]);
for (i = 0; i < card->nb_DAC; i += 2) { for (i = 0; i < card->nb_DAC; i += 2) {
parentTabColumn = create_group_control(&mmc, group++, parentTab, parentTabColumn = create_group_control(&mmc, group++, parentTab,
S_null, string_list[(i / 2) + 11]); S_null, string_list[(i / 2) + 11]);
create_channel_control(&mmc, channel++, parentTabColumn, NULL); create_channel_control(&mmc, channel++, parentTabColumn, NULL);
} }
if (card->spdif_config & NO_IN_YES_OUT) { if (card->spdif_config & NO_IN_YES_OUT) {
parentTabColumn = create_group_control(&mmc, group++, parentTab, parentTabColumn = create_group_control(&mmc, group++, parentTab,
S_null, string_list[15]); S_null, string_list[15]);
create_channel_control(&mmc, MAX_HARDWARE_VOLUME - 2, create_channel_control(&mmc, MAX_HARDWARE_VOLUME - 2,
parentTabColumn, NULL); parentTabColumn, NULL);
} }
//Input //Input
channel = MAX_HARDWARE_VOLUME; channel = MAX_HARDWARE_VOLUME;
for (i = 0; i < card->nb_ADC; i += 2) { for (i = 0; i < card->nb_ADC; i += 2) {
parentTabColumn = create_group_control(&mmc, group++, parentTab, parentTabColumn = create_group_control(&mmc, group++, parentTab,
S_null, string_list[(i / 2) + 17]); S_null, string_list[(i / 2) + 17]);
create_channel_control(&mmc, channel++, parentTabColumn, NULL); create_channel_control(&mmc, channel++, parentTabColumn, NULL);
} }
if (card->spdif_config & YES_IN_NO_OUT) { if (card->spdif_config & YES_IN_NO_OUT) {
parentTabColumn = create_group_control(&mmc, group++, parentTab, parentTabColumn = create_group_control(&mmc, group++, parentTab,
S_null, string_list[21]); S_null, string_list[21]);
create_channel_control(&mmc, 2 * MAX_HARDWARE_VOLUME - 2, create_channel_control(&mmc, 2 * MAX_HARDWARE_VOLUME - 2,
parentTabColumn, NULL); parentTabColumn, NULL);
} }
TRACE_VV("Return %ld control(s)\n", nb_control_created); TRACE_VV("Return %ld control(s)\n", nb_control_created);
@@ -969,19 +985,19 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
{ {
int buff, chan_i = 0, chan_o = 0; int buff, chan_i = 0, chan_o = 0;
TRACE_VV("flags = %#x\n", (int)data->flags); TRACE_VV("flags = %#lx\n", data->flags);
TRACE_VV("request_playback_buffers = %d\n", TRACE_VV("request_playback_buffers = %ld\n",
(int)data->request_playback_buffers); data->request_playback_buffers);
TRACE_VV("request_playback_channels = %d\n", TRACE_VV("request_playback_channels = %ld\n",
(int)data->request_playback_channels); data->request_playback_channels);
TRACE_VV("request_playback_buffer_size = %#x\n", TRACE_VV("request_playback_buffer_size = %lx\n",
(int)data->request_playback_buffer_size); data->request_playback_buffer_size);
TRACE_VV("request_record_buffers = %d\n", TRACE_VV("request_record_buffers = %ld\n",
(int)data->request_record_buffers); data->request_record_buffers);
TRACE_VV("request_record_channels = %d\n", TRACE_VV("request_record_channels = %ld\n",
(int)data->request_record_channels); data->request_record_channels);
TRACE_VV("request_record_buffer_size = %#x\n", TRACE_VV("request_record_buffer_size = %lx\n",
(int)data->request_record_buffer_size); data->request_record_buffer_size);
for (buff = 0; buff < SWAPPING_BUFFERS; buff++) { for (buff = 0; buff < SWAPPING_BUFFERS; buff++) {
uint32 stride_o = MAX_DAC * SAMPLE_SIZE; uint32 stride_o = MAX_DAC * SAMPLE_SIZE;
@@ -993,26 +1009,26 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
for (chan_o = 0; chan_o < card->nb_DAC; chan_o++) { for (chan_o = 0; chan_o < card->nb_DAC; chan_o++) {
//Analog STEREO output //Analog STEREO output
data->playback_buffers[buff][chan_o].base = card->log_addr_pb data->playback_buffers[buff][chan_o].base = card->log_addr_pb
+ buf_o * buff + SAMPLE_SIZE * chan_o; + buf_o * buff + SAMPLE_SIZE * chan_o;
data->playback_buffers[buff][chan_o].stride = stride_o; data->playback_buffers[buff][chan_o].stride = stride_o;
TRACE_VV("pb_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_o, TRACE_VV("pb_buffer[%ld][%ld] = %p\n", buff, chan_o,
(int)data->playback_buffers[buff][chan_o].base); data->playback_buffers[buff][chan_o].base);
} }
if (card->spdif_config & NO_IN_YES_OUT) { if (card->spdif_config & NO_IN_YES_OUT) {
//SPDIF STEREO output //SPDIF STEREO output
data->playback_buffers[buff][chan_o].base = card->log_addr_pb data->playback_buffers[buff][chan_o].base = card->log_addr_pb
+ buf_o * buff + SAMPLE_SIZE * SPDIF_LEFT; + buf_o * buff + SAMPLE_SIZE * SPDIF_LEFT;
data->playback_buffers[buff][chan_o].stride = stride_o; data->playback_buffers[buff][chan_o].stride = stride_o;
TRACE_VV("pb_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_o, TRACE_VV("pb_buffer[%ld][%ld] = %p\n", buff, chan_o,
(int)data->playback_buffers[buff][chan_o].base); data->playback_buffers[buff][chan_o].base);
chan_o++; chan_o++;
data->playback_buffers[buff][chan_o].base = card->log_addr_pb data->playback_buffers[buff][chan_o].base = card->log_addr_pb
+ buf_o * buff + SAMPLE_SIZE * SPDIF_RIGHT; + buf_o * buff + SAMPLE_SIZE * SPDIF_RIGHT;
data->playback_buffers[buff][chan_o].stride = stride_o; data->playback_buffers[buff][chan_o].stride = stride_o;
TRACE_VV("pb_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_o, TRACE_VV("pb_buffer[%ld][%ld] = %p\n", buff, chan_o,
(int)data->playback_buffers[buff][chan_o].base); data->playback_buffers[buff][chan_o].base);
chan_o++; chan_o++;
} }
} }
@@ -1021,42 +1037,42 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
for (chan_i = 0; chan_i < card->nb_ADC; chan_i++) { for (chan_i = 0; chan_i < card->nb_ADC; chan_i++) {
//Analog STEREO input //Analog STEREO input
data->record_buffers[buff][chan_i].base = card->log_addr_rec data->record_buffers[buff][chan_i].base = card->log_addr_rec
+ buf_i * buff + SAMPLE_SIZE * chan_i; + buf_i * buff + SAMPLE_SIZE * chan_i;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_VV("rec_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_i, TRACE_VV("rec_buffer[%ld][%ld] = %p\n", buff, chan_i,
(int)data->record_buffers[buff][chan_i].base); data->record_buffers[buff][chan_i].base);
} }
if (card->spdif_config & YES_IN_NO_OUT) { if (card->spdif_config & YES_IN_NO_OUT) {
//SPDIF STEREO input //SPDIF STEREO input
data->record_buffers[buff][chan_i].base = card->log_addr_rec data->record_buffers[buff][chan_i].base = card->log_addr_rec
+ buf_i * buff + SAMPLE_SIZE * SPDIF_LEFT; + buf_i * buff + SAMPLE_SIZE * SPDIF_LEFT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_VV("rec_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_i, TRACE_VV("rec_buffer[%ld][%ld] = %p\n", buff, chan_i,
(int)data->record_buffers[buff][chan_i].base); data->record_buffers[buff][chan_i].base);
chan_i++; chan_i++;
data->record_buffers[buff][chan_i].base = card->log_addr_rec data->record_buffers[buff][chan_i].base = card->log_addr_rec
+ buf_i * buff + SAMPLE_SIZE * SPDIF_RIGHT; + buf_i * buff + SAMPLE_SIZE * SPDIF_RIGHT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_VV("rec_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_i, TRACE_VV("rec_buffer[%ld][%ld] = %p\n", buff, chan_i,
(int)data->record_buffers[buff][chan_i].base); data->record_buffers[buff][chan_i].base);
chan_i++; chan_i++;
} }
//The digital mixer output //The digital mixer output
data->record_buffers[buff][chan_i].base = card->log_addr_rec data->record_buffers[buff][chan_i].base = card->log_addr_rec
+ buf_i * buff + SAMPLE_SIZE * MIXER_OUT_LEFT; + buf_i * buff + SAMPLE_SIZE * MIXER_OUT_LEFT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_VV("rec_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_i, TRACE_VV("rec_buffer[%ld][%ld] = %p\n", buff, chan_i,
(int)data->record_buffers[buff][chan_i].base); data->record_buffers[buff][chan_i].base);
chan_i++; chan_i++;
data->record_buffers[buff][chan_i].base = card->log_addr_rec data->record_buffers[buff][chan_i].base = card->log_addr_rec
+ buf_i * buff + SAMPLE_SIZE * MIXER_OUT_RIGHT; + buf_i * buff + SAMPLE_SIZE * MIXER_OUT_RIGHT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_VV("rec_buffer[%d][%d] = %#x\n", (int)buff, (int)chan_i, TRACE_VV("rec_buffer[%ld][%ld] = %p\n", buff, chan_i,
(int)data->record_buffers[buff][chan_i].base); data->record_buffers[buff][chan_i].base);
chan_i++; chan_i++;
} }
} }
@@ -1065,22 +1081,20 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
data->return_playback_channels = card->total_output_channels; data->return_playback_channels = card->total_output_channels;
data->return_playback_buffer_size = card->buffer_size; data->return_playback_buffer_size = card->buffer_size;
TRACE("return_playback_buffers = %d\n", TRACE("return_playback_buffers = %ld\n", data->return_playback_buffers);
(int)data->return_playback_buffers); TRACE("return_playback_channels = %ld\n", data->return_playback_channels);
TRACE("return_playback_channels = %d\n", TRACE("return_playback_buffer_size = %ld\n",
(int)data->return_playback_channels); data->return_playback_buffer_size);
TRACE("return_playback_buffer_size = %d\n",
(int)data->return_playback_buffer_size);
data->return_record_buffers = SWAPPING_BUFFERS; data->return_record_buffers = SWAPPING_BUFFERS;
data->return_record_channels = card->total_input_channels; data->return_record_channels = card->total_input_channels;
data->return_record_channels = chan_i; data->return_record_channels = chan_i;
data->return_record_buffer_size = card->buffer_size; data->return_record_buffer_size = card->buffer_size;
TRACE("return_record_buffers = %d\n",(int)data->return_record_buffers); TRACE("return_record_buffers = %ld\n", data->return_record_buffers);
TRACE("return_record_channels = %d\n", (int)data->return_record_channels); TRACE("return_record_channels = %ld\n", data->return_record_channels);
TRACE("return_record_buffer_size = %d\n", TRACE("return_record_buffer_size = %ld\n",
(int)data->return_record_buffer_size); data->return_record_buffer_size);
start_DMA(card); start_DMA(card);
@@ -1105,7 +1119,7 @@ ice1712_buffer_exchange(ice1712 *card, multi_buffer_info *data)
buffer_info.flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD; buffer_info.flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD;
if (acquire_sem_etc(card->buffer_ready_sem, 1, B_RELATIVE_TIMEOUT if (acquire_sem_etc(card->buffer_ready_sem, 1, B_RELATIVE_TIMEOUT
| B_CAN_INTERRUPT, 50000) == B_TIMED_OUT) { | B_CAN_INTERRUPT, 50000) == B_TIMED_OUT) {
TRACE("buffer_exchange timeout\n"); TRACE("buffer_exchange timeout\n");
}; };
@@ -1115,13 +1129,15 @@ ice1712_buffer_exchange(ice1712 *card, multi_buffer_info *data)
buffer_info.played_real_time = card->played_time; buffer_info.played_real_time = card->played_time;
buffer_info.played_frames_count = card->frames_count; buffer_info.played_frames_count = card->frames_count;
buffer_info.playback_buffer_cycle = (card->buffer - 1) buffer_info.playback_buffer_cycle = (card->buffer - 1)
% SWAPPING_BUFFERS; //Buffer played % SWAPPING_BUFFERS; //Buffer played
buffer_info._reserved_0 = 0;
// Record buffers info // Record buffers info
buffer_info.recorded_real_time = card->played_time; buffer_info.recorded_real_time = card->played_time;
buffer_info.recorded_frames_count = card->frames_count; buffer_info.recorded_frames_count = card->frames_count;
buffer_info.record_buffer_cycle = (card->buffer - 1) buffer_info.record_buffer_cycle = (card->buffer - 1)
% SWAPPING_BUFFERS; //Buffer filled % SWAPPING_BUFFERS; //Buffer filled
buffer_info._reserved_1 = card->total_output_channels;
unlock(cpu_status); unlock(cpu_status);
src/add-ons/kernel/drivers/audio/ice1712/multi.h
+11 -9
View File
@@ -31,14 +31,14 @@
#define ICE1712_MULTI_CONTROL_INDEX_MASK (0x00000FFF) #define ICE1712_MULTI_CONTROL_INDEX_MASK (0x00000FFF)
#define ICE1712_MULTI_SET_CHANNEL(_c_) ((_c_ << 20) & \ #define ICE1712_MULTI_SET_CHANNEL(_c_) ((_c_ << 20) & \
ICE1712_MULTI_CONTROL_CHANNEL_MASK) ICE1712_MULTI_CONTROL_CHANNEL_MASK)
#define ICE1712_MULTI_GET_CHANNEL(_c_) ((_c_ & \ #define ICE1712_MULTI_GET_CHANNEL(_c_) ((_c_ & \
ICE1712_MULTI_CONTROL_CHANNEL_MASK) >> 20) ICE1712_MULTI_CONTROL_CHANNEL_MASK) >> 20)
#define ICE1712_MULTI_SET_INDEX(_i_) (_i_ & \ #define ICE1712_MULTI_SET_INDEX(_i_) (_i_ & \
ICE1712_MULTI_CONTROL_INDEX_MASK) ICE1712_MULTI_CONTROL_INDEX_MASK)
#define ICE1712_MULTI_GET_INDEX(_i_) (_i_ & \ #define ICE1712_MULTI_GET_INDEX(_i_) (_i_ & \
ICE1712_MULTI_CONTROL_INDEX_MASK) ICE1712_MULTI_CONTROL_INDEX_MASK)
/* /*
#define ICE1712_MULTI_CONTROL_VOLUME_PB (0x00010000) #define ICE1712_MULTI_CONTROL_VOLUME_PB (0x00010000)
@@ -53,21 +53,23 @@
status_t ice1712_get_description(ice1712 *card, multi_description *data); status_t ice1712_get_description(ice1712 *card, multi_description *data);
status_t ice1712_get_enabled_channels(ice1712 *card, status_t ice1712_get_enabled_channels(ice1712 *card,
multi_channel_enable *data); multi_channel_enable *data);
status_t ice1712_set_enabled_channels(ice1712 *card, status_t ice1712_set_enabled_channels(ice1712 *card,
multi_channel_enable *data); multi_channel_enable *data);
status_t ice1712_get_global_format(ice1712 *card, multi_format_info *data); status_t ice1712_get_global_format(ice1712 *card, multi_format_info *data);
status_t ice1712_set_global_format(ice1712 *card, multi_format_info *data); status_t ice1712_set_global_format(ice1712 *card, multi_format_info *data);
status_t ice1712_get_mix(ice1712 *card, multi_mix_value_info *data); status_t ice1712_get_mix(ice1712 *card, multi_mix_value_info *data);
status_t ice1712_set_mix(ice1712 *card, multi_mix_value_info *data); status_t ice1712_set_mix(ice1712 *card, multi_mix_value_info *data);
status_t ice1712_list_mix_channels(ice1712 *card, status_t ice1712_list_mix_channels(ice1712 *card,
multi_mix_channel_info *data); multi_mix_channel_info *data);
status_t ice1712_list_mix_controls(ice1712 *card, status_t ice1712_list_mix_controls(ice1712 *card,
multi_mix_control_info *data); multi_mix_control_info *data);
status_t ice1712_list_mix_connections(ice1712 *card, status_t ice1712_list_mix_connections(ice1712 *card,
multi_mix_connection_info *data); multi_mix_connection_info *data);
status_t ice1712_get_buffers(ice1712 *card, multi_buffer_list *data); status_t ice1712_get_buffers(ice1712 *card, multi_buffer_list *data);
status_t ice1712_buffer_exchange(ice1712 *card, multi_buffer_info *data); status_t ice1712_buffer_exchange(ice1712 *card, multi_buffer_info *data);
status_t ice1712_buffer_force_stop(ice1712 *card); status_t ice1712_buffer_force_stop(ice1712 *card);
#endif //_ICE1712_MULTI_H_ #endif //_ICE1712_MULTI_H_