haiku.git

/*
 * Copyright 2004-2015 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Jérôme Duval, jerome.duval@free.fr
 *		Marcus Overhagen, marcus@overhagen.de
 *		Jérôme Lévêque, leveque.jerome@gmail.com
 */


#include "ice1712.h"
#include "ice1712_reg.h"
#include "io.h"
#include "multi.h"
#include "util.h"

#include <KernelExport.h>
#include <Drivers.h>
#include <OS.h>
#include <midi_driver.h>
#include <drivers/driver_settings.h>

#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

static status_t ice1712Settings_load(ice1712 *card);
status_t ice1712Settings_apply(ice1712 *card);
static int32 ice1712HW_interrupt(void *arg);
static status_t ice1712HW_setup(ice1712 *ice);
static void ice1712HW_shutdown(ice1712 *ice);

extern device_hooks ice1712Midi_hooks;
extern device_hooks ice1712Audio_hooks;
void ice1712Midi_interrupt(int32 op, void *data);

pci_module_info *pci;
generic_mpu401_module *mpu401;

int32 num_cards = 0;
ice1712 cards[NUM_CARDS];

//3 interfaces (2 midi + 1 audio) can be defined for each card
static char *names[NUM_CARDS*3+1];
static int32 num_names = 0;

#define HMULTI_AUDIO_DEV_PATH "audio/hmulti/ice1712"

//Haiku Driver API
//----------------

int32 api_version = B_CUR_DRIVER_API_VERSION;

extern "C" status_t
init_hardware(void)
{
	int ix = 0;
	pci_info info;

	memset(cards, 0, sizeof(ice1712) * NUM_CARDS);
	ITRACE("@@ init_hardware()\n");

	if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci))
		return ENOSYS;

	while ((*pci->get_nth_pci_info)(ix, &info) == B_OK) {
		if ((info.vendor_id == ICE1712_VENDOR_ID)
			&& (info.device_id == ICE1712_DEVICE_ID)) {
			ITRACE("Found at least 1 card\n");
			put_module(B_PCI_MODULE_NAME);
			return B_OK;
		}
		ix++;
	}
	put_module(B_PCI_MODULE_NAME);
	return ENODEV;
}


extern "C" status_t
init_driver(void)
{
	int i = 0;
	status_t err;
	num_cards = 0;

	ITRACE("@@ init_driver()\n");

	if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci))
		return ENOSYS;

	if (get_module(B_MPU_401_MODULE_NAME, (module_info **) &mpu401)) {
		put_module(B_PCI_MODULE_NAME);
		return ENOSYS;
	}

	while ((*pci->get_nth_pci_info)(i, &cards[num_cards].info) == B_OK) {
		//TODO check other Vendor_ID and DEVICE_ID
		if ((cards[num_cards].info.vendor_id == ICE1712_VENDOR_ID)
			&& (cards[num_cards].info.device_id == ICE1712_DEVICE_ID)) {
			if (num_cards == NUM_CARDS) {
				ITRACE("Too many ice1712 cards installed!\n");
				break;
			}

			if ((err = (*pci->reserve_device)(cards[num_cards].info.bus,
				cards[num_cards].info.device,
				cards[num_cards].info.function,
				DRIVER_NAME, &cards[num_cards])) < B_OK) {
				ITRACE_VV("%s: failed to reserve_device(%d, %d, %d,): %s\n",
					DRIVER_NAME, cards[num_cards].info.bus,
					cards[num_cards].info.device,
					cards[num_cards].info.function, strerror(err));
				continue;
			}

			ice1712Settings_load(&cards[num_cards]);

			if (ice1712HW_setup(&cards[num_cards]) != B_OK) {
			//Vendor_ID and Device_ID has been modified
				ITRACE("Setup of ice1712 %" B_PRIu32 " failed\n", num_cards + 1);
				(*pci->unreserve_device)(cards[num_cards].info.bus,
					cards[num_cards].info.device,
					cards[num_cards].info.function,
					DRIVER_NAME, &cards[num_cards]);
			} else {
				num_cards++;
			}
		}
		i++;
	}

	ITRACE("Succesfully initialised card : %" B_PRIu32 "\n", num_cards);

	if (num_cards == 0) {
		put_module(B_PCI_MODULE_NAME);
		put_module(B_MPU_401_MODULE_NAME);
		return ENODEV;
	}
	return B_OK;
}


extern "C" void
uninit_driver(void)
{
	int ix, cnt = num_cards;

	ITRACE("@@ uninit_driver()\n");

	num_cards = 0;

	for (ix = 0; ix < cnt; ix++) {
		ice1712HW_shutdown(&cards[ix]);
		(*pci->unreserve_device)(cards[ix].info.bus,
			cards[ix].info.device, cards[ix].info.function,
			DRIVER_NAME, &cards[ix]);
	}
	memset(&cards, 0, sizeof(cards));
	put_module(B_MPU_401_MODULE_NAME);
	put_module(B_PCI_MODULE_NAME);
}


extern "C" const char **
publish_devices(void)
{
	int ix = 0;
	ITRACE("@@ publish_devices()\n");

	for (ix = 0; names[ix]; ix++) {
		ITRACE("publish %s\n", names[ix]);
	}
	return (const char **)names;
}


extern "C" device_hooks *
find_device(const char * name)
{
	int ix, midi;

	ITRACE("@@ find_device()\n");

	for (ix = 0; ix < num_cards; ix++) {
		for (midi = 0; midi < MAX_MIDI_INTERFACE; midi++) {
			if (!strcmp(cards[ix].midiItf[midi].name, name)) {
				return &ice1712Midi_hooks;
			}
		}

		if (!strcmp(cards[ix].name, name)) {
			return &ice1712Audio_hooks;
		}
	}
	ITRACE("!!! failed !!!\n");
	return NULL;
}

//ICE1712 driver - Hardware
//-------------------------

int32
ice1712HW_interrupt(void *arg)
{
	ice1712 *ice = (ice1712*)arg;
	uint8 reg8 = 0;
	uint16 reg16 = 0;
	uint32 status = B_UNHANDLED_INTERRUPT;

	// interrupt from DMA PATH
	reg8 = read_mt_uint8(ice, MT_DMA_INT_MASK_STATUS);
	if (reg8 != 0) {
		ice->buffer++;
		ice->played_time = system_time();
		ice->frames_count += ice->buffer_size;

		release_sem_etc(ice->buffer_ready_sem, 1, B_DO_NOT_RESCHEDULE);
		write_mt_uint8(ice, MT_DMA_INT_MASK_STATUS, reg8);
		status = B_HANDLED_INTERRUPT;
	}

	// interrupt from Controller Registers
	reg8 = read_ccs_uint8(ice, CCS_INTERRUPT_STATUS);
	if (reg8 != 0) {
		bool ret;
		if (reg8 & CCS_INTERRUPT_MIDI_1) {
			ret = (*mpu401->interrupt_hook)(ice->midiItf[0].mpu401device);
			if (ret) {
				//Do not ack, cause more datas are available
				reg8 &= ~CCS_INTERRUPT_MIDI_1;
			}
		}

		if (reg8 & CCS_INTERRUPT_MIDI_2) {
			ret = (*mpu401->interrupt_hook)(ice->midiItf[1].mpu401device);
			if (ret) {
				//Do not ack, cause more datas are available
				reg8 &= ~CCS_INTERRUPT_MIDI_2;
			}
		}

		if (reg8 != 0) {
			write_ccs_uint8(ice, CCS_INTERRUPT_STATUS, reg8);
			status = B_HANDLED_INTERRUPT;
		}
	}

	// interrupt from DS PATH
	reg16 = read_ds_uint16(ice, DS_DMA_INT_STATUS);
	if (reg16 != 0) {
		//Ack interrupt
		write_ds_uint16(ice, DS_DMA_INT_STATUS, reg16);
		status = B_HANDLED_INTERRUPT;
	}

	return status;
}


status_t
ice1712HW_setup(ice1712 *ice)
{
	int i;
	uint8 reg8 = 0;
	uint16 mute;

	ice->irq = ice->info.u.h0.interrupt_line;
	ice->Controller = ice->info.u.h0.base_registers[0];
	ice->DDMA = ice->info.u.h0.base_registers[1];
	ice->DMA_Path = ice->info.u.h0.base_registers[2];
	ice->Multi_Track = ice->info.u.h0.base_registers[3];

	// Soft Reset
	write_ccs_uint8(ice, CCS_CONTROL_STATUS, 0x81);
	snooze(200000);
	write_ccs_uint8(ice, CCS_CONTROL_STATUS, 0x01);
	snooze(200000);

	read_eeprom(ice, ice->eeprom_data);

	write_ccs_uint8(ice, CCS_SERR_SHADOW, 0x01);

	//Write all configurations register from EEProm
	ice->info.device_id = ice->eeprom_data[E2PROM_MAP_SUBVENDOR_HIGH] << 8
		| ice->eeprom_data[E2PROM_MAP_SUBVENDOR_LOW];
	ice->info.vendor_id = ice->eeprom_data[E2PROM_MAP_SUBDEVICE_HIGH] << 8
		| ice->eeprom_data[E2PROM_MAP_SUBDEVICE_LOW];
	ice->config.product = (ice1712Product)(ice->info.vendor_id << 16
		| ice->info.device_id);
	ITRACE("Product ID : 0x%x\n", ice->config.product);

	write_cci_uint8(ice, CCI_GPIO_WRITE_MASK,
		ice->eeprom_data[E2PROM_MAP_GPIOMASK]);
	write_cci_uint8(ice, CCI_GPIO_DATA,
		ice->eeprom_data[E2PROM_MAP_GPIOSTATE]);
	write_cci_uint8(ice, CCI_GPIO_DIRECTION_CONTROL,
		ice->eeprom_data[E2PROM_MAP_GPIODIR]);

	ITRACE("CCI_GPIO_WRITE_MASK : 0x%x\n",
		ice->eeprom_data[E2PROM_MAP_GPIOMASK]);
	ITRACE("CCI_GPIO_DATA : 0x%x\n",
		ice->eeprom_data[E2PROM_MAP_GPIOSTATE]);
	ITRACE("CCI_GPIO_DIRECTION_CONTROL : 0x%x\n",
		ice->eeprom_data[E2PROM_MAP_GPIODIR]);

	//Write Configuration in the PCI configuration Register
	(pci->write_pci_config)(ice->info.bus, ice->info.device,
		ice->info.function, 0x60, 1, ice->eeprom_data[E2PROM_MAP_CONFIG]);
	(pci->write_pci_config)(ice->info.bus, ice->info.device,
		ice->info.function, 0x61, 1, ice->eeprom_data[E2PROM_MAP_ACL]);
	(pci->write_pci_config)(ice->info.bus, ice->info.device,
		ice->info.function, 0x62, 1, ice->eeprom_data[E2PROM_MAP_I2S]);
	(pci->write_pci_config)(ice->info.bus, ice->info.device,
		ice->info.function, 0x63, 1, ice->eeprom_data[E2PROM_MAP_SPDIF]);

	ITRACE("E2PROM_MAP_CONFIG : 0x%x\n", ice->eeprom_data[E2PROM_MAP_CONFIG]);
	reg8 = ice->eeprom_data[E2PROM_MAP_CONFIG];
	//Bits signification for E2PROM_MAP_CONFIG Byte
	//
	// 8   7   6   5   4   3   2   1   0
	//           |-D-|-C-|---B---|---A---
	//
	// D : MPU401 number minus 1
	// C : AC'97
	// B : Stereo ADC number minus 1 (=> 1 to 4)
	// A : Stereo DAC number minus 1 (=> 1 to 4)

	ice->config.nb_DAC = ((reg8 & 0x03) + 1) * 2;
	reg8 >>= 2;
	ice->config.nb_ADC = ((reg8 & 0x03) + 1) * 2;
	reg8 >>= 2;

	if ((reg8 & 0x01) != 0) {//Consumer AC'97 Exist
		ITRACE("Consumer AC'97 does exist\n");
		//For now do nothing
/*		write_ccs_uint8(ice, CCS_CONS_AC97_COMMAND_STATUS, 0x40);
		snooze(10000);
		write_ccs_uint8(ice, CCS_CONS_AC97_COMMAND_STATUS, 0x00);
		snooze(20000);
*/	} else {
		ITRACE("Consumer AC'97 does NOT exist\n");
	}
	reg8 >>= 1;
	ice->config.nb_MPU401 = (reg8 & 0x1) + 1;

	if (ice->config.nb_MPU401 > 0) {
		sprintf(ice->midiItf[0].name, "midi/ice1712/%ld/1", ice - cards + 1);

		(*mpu401->create_device)(ice->Controller + CCS_MIDI_1_DATA,
			&ice->midiItf[0].mpu401device,
			0x14121712,
			ice1712Midi_interrupt,
			&ice->midiItf[0]);

		names[num_names++] = ice->midiItf[0].name;
		ice->midiItf[0].card = ice;
		ice->midiItf[0].int_mask = CCS_INTERRUPT_MIDI_1;
	}

	if (ice->config.nb_MPU401 > 1) {
		sprintf(ice->midiItf[1].name, "midi/ice1712/%ld/2", ice - cards + 1);

		(*mpu401->create_device)(ice->Controller + CCS_MIDI_2_DATA,
			&ice->midiItf[1].mpu401device,
			0x14121712,
			ice1712Midi_interrupt,
			&ice->midiItf[1]);

		names[num_names++] = ice->midiItf[1].name;
		ice->midiItf[1].card = ice;
		ice->midiItf[1].int_mask = CCS_INTERRUPT_MIDI_2;
	}

	ITRACE("E2PROM_MAP_SPDIF : 0x%x\n", ice->eeprom_data[E2PROM_MAP_SPDIF]);
	ice->config.spdif = ice->eeprom_data[E2PROM_MAP_SPDIF];

	switch (ice->config.product) {
		case ICE1712_SUBDEVICE_DELTA66 :
		case ICE1712_SUBDEVICE_DELTA44 :
			ice->CommLines.clock = DELTA66_CLK;
			ice->CommLines.data_in = 0;
			ice->CommLines.data_out = DELTA66_DOUT;
			ice->CommLines.cs_mask = DELTA66_CLK | DELTA66_DOUT
				| DELTA66_CS_MASK;
			break;
		case ICE1712_SUBDEVICE_DELTA410 :
		case ICE1712_SUBDEVICE_AUDIOPHILE_2496 :
		case ICE1712_SUBDEVICE_DELTADIO2496 :
			ice->CommLines.clock = AP2496_CLK;
			ice->CommLines.data_in = AP2496_DIN;
			ice->CommLines.data_out = AP2496_DOUT;
			ice->CommLines.cs_mask = AP2496_CLK | AP2496_DIN
				| AP2496_DOUT | AP2496_CS_MASK;
			break;
		case ICE1712_SUBDEVICE_DELTA1010 :
		case ICE1712_SUBDEVICE_DELTA1010LT :
			ice->CommLines.clock = DELTA1010LT_CLK;
			ice->CommLines.data_in = DELTA1010LT_DIN;
			ice->CommLines.data_out = DELTA1010LT_DOUT;
			ice->CommLines.cs_mask = DELTA1010LT_CLK | DELTA1010LT_DIN
				| DELTA1010LT_DOUT | DELTA1010LT_CS_NONE;
			break;
		case ICE1712_SUBDEVICE_VX442 :
			ice->CommLines.clock = VX442_CLK;
			ice->CommLines.data_in = VX442_DIN;
			ice->CommLines.data_out = VX442_DOUT;
			ice->CommLines.cs_mask = VX442_CLK | VX442_DIN | VX442_DOUT
				| VX442_CS_MASK;
			break;
	}

	sprintf(ice->name, "%s/%ld", HMULTI_AUDIO_DEV_PATH, ice - cards + 1);
	names[num_names++] = ice->name;
	names[num_names] = NULL;

	ice->buffer_ready_sem = create_sem(0, "Buffer Exchange");
	if (ice->buffer_ready_sem < B_OK) {
		return ice->buffer_ready_sem;
	}

	install_io_interrupt_handler(ice->irq, ice1712HW_interrupt, ice, 0);

	ice->mem_id_pb = alloc_mem(&ice->phys_pb, &ice->log_addr_pb,
		PLAYBACK_BUFFER_TOTAL_SIZE, "playback buffer");
	if (ice->mem_id_pb < B_OK) {
		remove_io_interrupt_handler(ice->irq, ice1712HW_interrupt, ice);
		delete_sem(ice->buffer_ready_sem);
		return ice->mem_id_pb;
	}

	ice->mem_id_rec = alloc_mem(&ice->phys_rec, &ice->log_addr_rec,
		RECORD_BUFFER_TOTAL_SIZE, "record buffer");
	if (ice->mem_id_rec < B_OK) {
		remove_io_interrupt_handler(ice->irq, ice1712HW_interrupt, ice);
		delete_sem(ice->buffer_ready_sem);
		delete_area(ice->mem_id_pb);
		return(ice->mem_id_rec);
	}

	ice->config.samplingRate = 0x08;
	ice->buffer = 0;
	ice->frames_count = 0;
	ice->buffer_size = ice->settings.bufferSize;

	ice->total_output_channels = ice->config.nb_DAC;
	if (ice->config.spdif & SPDIF_OUT_PRESENT)
		ice->total_output_channels += 2;

	ice->total_input_channels = ice->config.nb_ADC + 2;
	if (ice->config.spdif & SPDIF_IN_PRESENT)
		ice->total_input_channels += 2;

	//Write bits in the GPIO
	write_cci_uint8(ice, CCI_GPIO_WRITE_MASK, ~(ice->CommLines.cs_mask));
	//Deselect CS
	write_cci_uint8(ice, CCI_GPIO_DATA, ice->CommLines.cs_mask);

	//Set the rampe volume to a faster one
	write_mt_uint16(ice, MT_VOLUME_CONTROL_RATE, 0x01);

	//All Analog outputs from DMA
	write_mt_uint16(ice, MT_ROUTING_CONTROL_PSDOUT, 0x0000);
	//All Digital output from DMA
	write_mt_uint16(ice, MT_ROUTING_CONTROL_SPDOUT, 0x0000);

	//Mute all input
	mute = (ICE1712_MUTE_VALUE << 0) | (ICE1712_MUTE_VALUE << 8);
	for (i = 0; i < 2 * ICE1712_HARDWARE_VOLUME; i++) {
		write_mt_uint8(ice, MT_VOLUME_CONTROL_CHANNEL_INDEX, i);
		write_mt_uint16(ice, MT_VOLUME_CONTROL_CHANNEL_INDEX, mute);
	}

	//Unmask Interrupt
	write_ccs_uint8(ice, CCS_CONTROL_STATUS, 0x41);

	reg8 = read_ccs_uint8(ice, CCS_INTERRUPT_MASK);
	ITRACE("-----CCS----- = %x\n", reg8);
	write_ccs_uint8(ice, CCS_INTERRUPT_MASK, 0xEF);

/*	reg16 = read_ds_uint16(ice, DS_DMA_INT_MASK);
	ITRACE("-----DS_DMA----- = %x\n", reg16);
	write_ds_uint16(ice, DS_DMA_INT_MASK, 0x0000);
*/
	reg8 = read_mt_uint8(ice, MT_DMA_INT_MASK_STATUS);
	ITRACE("-----MT_DMA----- = %x\n", reg8);
	write_mt_uint8(ice, MT_DMA_INT_MASK_STATUS, 0x00);

	return B_OK;
};


void
ice1712HW_shutdown(ice1712 *ice)
{
	delete_sem(ice->buffer_ready_sem);

	remove_io_interrupt_handler(ice->irq, ice1712HW_interrupt, ice);

	if (ice->mem_id_pb != B_ERROR)
		delete_area(ice->mem_id_pb);

	if (ice->mem_id_rec != B_ERROR)
		delete_area(ice->mem_id_rec);

	codec_write(ice, AK45xx_RESET_REGISTER, 0x00);
}

//ICE1712 driver - Hook
//---------------------

static status_t
ice1712Audio_open(const char *name, uint32 flags, void **cookie)
{
	int ix;
	ice1712 *card = NULL;
	ITRACE("** open(): %s\n", name);

	for (ix = 0; ix<num_cards; ix++) {
		if (!strcmp(cards[ix].name, name)) {
			card = &cards[ix];
		}
	}

	if (card == NULL) {
		ITRACE("open() card not found %s\n", name);
		for (ix=0; ix<num_cards; ix++) {
			ITRACE("open() card available %s\n", cards[ix].name);
		}
		return B_ERROR;
	}
	*cookie = cards;
	return B_OK;
}


static status_t
ice1712Audio_close(void *cookie)
{
	ITRACE("** close()\n");
	return B_OK;
}


static status_t
ice1712Audio_free(void *cookie)
{
	ITRACE("** free()\n");
	return B_OK;
}


static status_t
ice1712Audio_control(void *cookie, uint32 op, void *arg, size_t len)
{
	switch (op) {
		case B_MULTI_GET_DESCRIPTION :
			ITRACE("B_MULTI_GET_DESCRIPTION\n");
			return ice1712Get_Description((ice1712 *)cookie,
				(multi_description*)arg);
		case B_MULTI_GET_EVENT_INFO :
			ITRACE("B_MULTI_GET_EVENT_INFO\n");
			return B_ERROR;
		case B_MULTI_SET_EVENT_INFO :
			ITRACE("B_MULTI_SET_EVENT_INFO\n");
			return B_ERROR;
		case B_MULTI_GET_EVENT :
			ITRACE("B_MULTI_GET_EVENT\n");
			return B_ERROR;
		case B_MULTI_GET_ENABLED_CHANNELS :
			ITRACE("B_MULTI_GET_ENABLED_CHANNELS\n");
			return ice1712Get_Channel((ice1712*)cookie,
				(multi_channel_enable*)arg);
		case B_MULTI_SET_ENABLED_CHANNELS :
			ITRACE("B_MULTI_SET_ENABLED_CHANNELS\n");
			return ice1712Set_Channel((ice1712*)cookie,
				(multi_channel_enable*)arg);
		case B_MULTI_GET_GLOBAL_FORMAT :
			ITRACE("B_MULTI_GET_GLOBAL_FORMAT\n");
			return ice1712Get_Format((ice1712*)cookie,
				(multi_format_info *)arg);
		case B_MULTI_SET_GLOBAL_FORMAT :
			ITRACE("B_MULTI_SET_GLOBAL_FORMAT\n");
			return ice1712Set_Format((ice1712*)cookie,
				(multi_format_info *)arg);
		case B_MULTI_GET_CHANNEL_FORMATS :
			ITRACE("B_MULTI_GET_CHANNEL_FORMATS\n");
			return B_ERROR;
		case B_MULTI_SET_CHANNEL_FORMATS :
			ITRACE("B_MULTI_SET_CHANNEL_FORMATS\n");
			return B_ERROR;
		case B_MULTI_GET_MIX :
			ITRACE("B_MULTI_GET_MIX\n");
			return ice1712Get_MixValue((ice1712*)cookie,
				(multi_mix_value_info *)arg);
		case B_MULTI_SET_MIX :
			ITRACE("B_MULTI_SET_MIX\n");
			return ice1712Set_MixValue((ice1712*)cookie,
				(multi_mix_value_info *)arg);
		case B_MULTI_LIST_MIX_CHANNELS :
			ITRACE("B_MULTI_LIST_MIX_CHANNELS\n");
			return ice1712Get_MixValueChannel((ice1712*)cookie,
				(multi_mix_channel_info *)arg);
		case B_MULTI_LIST_MIX_CONTROLS :
			ITRACE("B_MULTI_LIST_MIX_CONTROLS\n");
			return ice1712Get_MixValueControls((ice1712*)cookie,
				(multi_mix_control_info *)arg);
		case B_MULTI_LIST_MIX_CONNECTIONS :
			ITRACE("B_MULTI_LIST_MIX_CONNECTIONS\n");
			return ice1712Get_MixValueConnections((ice1712*)cookie,
				(multi_mix_connection_info *)arg);
		case B_MULTI_GET_BUFFERS :
			ITRACE("B_MULTI_GET_BUFFERS\n");
			return ice1712Buffer_Get((ice1712*)cookie,
				(multi_buffer_list*)arg);
		case B_MULTI_SET_BUFFERS :
			ITRACE("B_MULTI_SET_BUFFERS\n");
			return B_ERROR;
		case B_MULTI_SET_START_TIME :
			ITRACE("B_MULTI_SET_START_TIME\n");
			return B_ERROR;
		case B_MULTI_BUFFER_EXCHANGE :
//			ITRACE("B_MULTI_BUFFER_EXCHANGE\n");
			return ice1712Buffer_Exchange((ice1712*)cookie,
				(multi_buffer_info *)arg);
		case B_MULTI_BUFFER_FORCE_STOP :
			ITRACE("B_MULTI_BUFFER_FORCE_STOP\n");
			return ice1712Buffer_Stop((ice1712*)cookie);
		case B_MULTI_LIST_EXTENSIONS :
			ITRACE("B_MULTI_LIST_EXTENSIONS\n");
			return B_ERROR;
		case B_MULTI_GET_EXTENSION :
			ITRACE("B_MULTI_GET_EXTENSION\n");
			return B_ERROR;
		case B_MULTI_SET_EXTENSION :
			ITRACE("B_MULTI_SET_EXTENSION\n");
			return B_ERROR;
		case B_MULTI_LIST_MODES :
			ITRACE("B_MULTI_LIST_MODES\n");
			return B_ERROR;
		case B_MULTI_GET_MODE :
			ITRACE("B_MULTI_GET_MODE\n");
			return B_ERROR;
		case B_MULTI_SET_MODE :
			ITRACE("B_MULTI_SET_MODE\n");
			return B_ERROR;

		default :
			ITRACE("ERROR: unknown multi_control %#x\n", (int)op);
			return B_ERROR;
	}
}


static status_t
ice1712Audio_read(void *cookie, off_t position, void *buf,
	size_t *num_bytes)
{
	ITRACE("** read()\n");
	*num_bytes = 0;
	return B_IO_ERROR;
}


static status_t
ice1712Audio_write(void *cookie, off_t position, const void *buffer,
	size_t *num_bytes)
{
	ITRACE("** write()\n");
	*num_bytes = 0;
	return B_IO_ERROR;
}


device_hooks ice1712Audio_hooks =
{
	ice1712Audio_open,
	ice1712Audio_close,
	ice1712Audio_free,
	ice1712Audio_control,
	ice1712Audio_read,
	ice1712Audio_write,
	NULL,
	NULL,
	NULL,
	NULL
};


//ICE1712 Drivers - Settings
//--------------------------


status_t
ice1712Settings_load(ice1712 *card)
{
	// get driver settings
	void *settings_handle = load_driver_settings("ice1712.settings");

	//Use a large enough value for modern computer
	card->settings.bufferSize = 512;

	if (settings_handle != NULL) {
		const char *item;
		char *end;

		item = get_driver_parameter(settings_handle,
			"buffer_size", "512", "512");
		if (item != NULL) {
			uint32 value = strtoul(item, &end, 0);
			if ((*end == '\0')
				&& (value >= MIN_BUFFER_FRAMES)
				&& (value <= MAX_BUFFER_FRAMES)) {
					card->settings.bufferSize = value;
			}
		}

		unload_driver_settings(settings_handle);
	}

	return B_OK;
}


status_t
ice1712Settings_apply(ice1712 *card)
{
	int i;
	uint16 val, mt30 = 0;
	uint32 mt34 = 0;

	for (i = 0; i < ICE1712_HARDWARE_VOLUME; i++) {
		//Select the channel
		write_mt_uint8(card, MT_VOLUME_CONTROL_CHANNEL_INDEX, i);

		if (card->settings.playback[i].mute == true) {
			val = (ICE1712_MUTE_VALUE << 0) | (ICE1712_MUTE_VALUE << 8);
		} else {
			uint8 volume = card->settings.playback[i].volume / -1.5;
			if (i & 1) {//a right channel
				val = ICE1712_MUTE_VALUE << 0; //Mute left volume
				val |= volume << 8;
			} else {//a left channel
				val = ICE1712_MUTE_VALUE << 8; //Mute right volume
				val |= volume << 0;
			}
		}

		write_mt_uint16(card, MT_LR_VOLUME_CONTROL,	val);
		ITRACE_VV("Apply Settings %d : 0x%x\n", i, val);
	}

	for (i = 0; i < ICE1712_HARDWARE_VOLUME; i++) {
		//Select the channel
		write_mt_uint8(card, MT_VOLUME_CONTROL_CHANNEL_INDEX,
			i + ICE1712_HARDWARE_VOLUME);

		if (card->settings.record[i].mute == true) {
			val = (ICE1712_MUTE_VALUE << 0) | (ICE1712_MUTE_VALUE << 8);
		} else {
			uint8 volume = card->settings.record[i].volume / -1.5;
			if (i & 1) {//a right channel
				val = ICE1712_MUTE_VALUE << 0; //Mute left volume
				val |= volume << 8;
			} else {//a left channel
				val = ICE1712_MUTE_VALUE << 8; //Mute right volume
				val |= volume << 0;
			}
		}

		write_mt_uint16(card, MT_LR_VOLUME_CONTROL,	val);
		ITRACE_VV("Apply Settings %d : 0x%x\n", i, val);
	}

	//Analog output selection
	for (i = 0; i < 4; i++) {
		uint8 out = card->settings.output[i];
		if (out == 0) {
			ITRACE_VV("Output %d is haiku output\n", i);
			//Nothing to do
		} else if (out <= (card->config.nb_ADC / 2)) {
			uint8 mt34_c;
			out--;
			ITRACE_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->config.nb_ADC / 2) + 1)
				&& (card->config.spdif & SPDIF_IN_PRESENT) != 0) {
			ITRACE_VV("Output %d is digital input\n", i);
			mt30 |= 0x0303 << (2 * i);
			mt34 |= 0x80 << (8 * i);
		} else {
			ITRACE_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->config.spdif & SPDIF_OUT_PRESENT) != 0) {
		uint16 mt32 = 0;
		uint8 out = card->settings.output[4];
		if (out == 0) {
			ITRACE_VV("Digital output is haiku output\n");
			//Nothing to do
		} else if (out <= (card->config.nb_ADC / 2)) {
			out--;
			ITRACE_VV("Digital output is input %d\n", out);
			mt32 |= 0x0202;
			mt32 |= (out * 2) << 8;
			mt32 |= (out * 2 + 1) << 12;
		} else if (out == ((card->config.nb_ADC / 2) + 1)
				&& (card->config.spdif & SPDIF_IN_PRESENT) != 0) {
			ITRACE_VV("Digital output is digital input\n");
			mt32 |= 0x800F;
		} else {
			ITRACE_VV("Digital output is digital Mixer\n");
			mt32 |= 0x0005;
		}

		write_mt_uint16(card, MT_ROUTING_CONTROL_SPDOUT, mt32);
	}

	return B_OK;
}