xref: /haiku/src/add-ons/kernel/drivers/audio/echo/echo.cpp (revision d3503944f052536d75afff2b89c0a9f0fdc9e83e)

//------------------------------------------------------------------------------
//
//  EchoGals/Echo24 BeOS Driver for Echo audio cards
//
//	Copyright (c) 2003, Jérôme Duval
//
//	Permission is hereby granted, free of charge, to any person obtaining a
//	copy of this software and associated documentation files (the "Software"),
//	to deal in the Software without restriction, including without limitation
//	the rights to use, copy, modify, merge, publish, distribute, sublicense,
//	and/or sell copies of the Software, and to permit persons to whom the
//	Software is furnished to do so, subject to the following conditions:
//
//	The above copyright notice and this permission notice shall be included in
//	all copies or substantial portions of the Software.
//
//	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//	DEALINGS IN THE SOFTWARE.

#include <KernelExport.h>
#include <Drivers.h>
#include <unistd.h>
#include "OsSupportBeOS.h"
#include "EchoGalsXface.h"
#include "C3g.h"
#include "CDarla24.h"
#include "CDarla.h"
#include "CGina.h"
#include "CGina24.h"
#include "CIndigo.h"
#include "CIndigoDJ.h"
#include "CIndigoIO.h"
#include "CLayla.h"
#include "CLayla24.h"
#include "CMia.h"
#include "CMona.h"
#include "echo.h"
#include "debug.h"
#include "util.h"

#ifdef CARDBUS
static cb_enabler_module_info	*cbemi;
struct _echodevs				devices;
static char						*names[NUM_CARDS];
int32 							num_names = 0;
static uint32					device_index = 0;
static sem_id					device_lock = 0;

static const cb_device_descriptor	descriptors[] = {
	{VENDOR_ID, DEVICE_ID_56301, 0xff, 0xff, 0xff}
};

#define COUNT_DESCRIPTOR			1

status_t cardbus_device_added(pci_info *info, void **cookie);
void cardbus_device_removed(void *cookie);

static cb_notify_hooks	cardbus_hooks = {
	cardbus_device_added, 		// Add entry point
	cardbus_device_removed 		// Remove entry point
};

#else // CARDBUS
static pci_module_info	*pci;
int32 num_cards;
echo_dev cards[NUM_CARDS];
int32 num_names;
char * names[NUM_CARDS*20+1];
#endif // CARDBUS

extern device_hooks multi_hooks;
#ifdef MIDI_SUPPORT
extern device_hooks midi_hooks;
#endif

int32 echo_int(void *arg);
status_t init_hardware(void);
status_t init_driver(void);
static void make_device_names(echo_dev * card);

static status_t echo_setup(echo_dev * card);
static void echo_shutdown(echo_dev *card);

void uninit_driver(void);
const char ** publish_devices(void);
device_hooks * find_device(const char * name);


/* Echo Memory management */

echo_mem *
echo_mem_new(echo_dev *card, size_t size)
{
	echo_mem *mem;

	if ((mem = (echo_mem *) malloc(sizeof(*mem))) == NULL)
		return (NULL);

	mem->area = alloc_mem(&mem->phy_base, &mem->log_base, size, "echo buffer", true);
	mem->size = size;
	if (mem->area < B_OK) {
		free(mem);
		return NULL;
	}
	return mem;
}


void
echo_mem_delete(echo_mem *mem)
{
	if (mem->area > B_OK)
		delete_area(mem->area);
	free(mem);
}


echo_mem *
echo_mem_alloc(echo_dev *card, size_t size)
{
	echo_mem *mem;

	mem = echo_mem_new(card, size);
	if (mem == NULL)
		return (NULL);

	LIST_INSERT_HEAD(&(card->mems), mem, next);

	return mem;
}


void
echo_mem_free(echo_dev *card, void *ptr)
{
	echo_mem 		*mem;

	LIST_FOREACH(mem, &card->mems, next) {
		if (mem->log_base != ptr)
			continue;
		LIST_REMOVE(mem, next);

		echo_mem_delete(mem);
		break;
	}
}

/*	Echo stream functions */

extern char *pStatusStrs[ECHOSTATUS_LAST];

status_t
echo_stream_set_audioparms(echo_stream *stream, uint8 channels,
	uint8 bitsPerSample, uint32 sample_rate, uint8 index)
{
	int32 			i;
	uint8 			sample_size, frame_size;
	ECHOGALS_OPENAUDIOPARAMETERS	open_params;
	ECHOGALS_CLOSEAUDIOPARAMETERS  close_params;
	ECHOGALS_AUDIOFORMAT			format_params;
	ECHOSTATUS status;

	LOG(("echo_stream_set_audioparms\n"));

	if (stream->pipe >= 0) {
		close_params.wPipeIndex = stream->pipe;
		status = stream->card->pEG->CloseAudio(&close_params);
		if (status != ECHOSTATUS_OK && status != ECHOSTATUS_CHANNEL_NOT_OPEN) {
			PRINT(("echo_stream_set_audioparms : CloseAudio failed\n"));
			PRINT((" status: %s \n", pStatusStrs[status]));
			return B_ERROR;
		}
	}

	open_params.bIsCyclic = TRUE;
	open_params.Pipe.nPipe = index;
	open_params.Pipe.bIsInput = stream->use == ECHO_USE_RECORD ? TRUE : FALSE;
	open_params.Pipe.wInterleave = channels;
	open_params.ProcessId = NULL;

	status = stream->card->pEG->OpenAudio(&open_params, &stream->pipe);
	if (status != ECHOSTATUS_OK) {
		PRINT(("echo_stream_set_audioparms : OpenAudio failed\n"));
		PRINT((" status: %s \n", pStatusStrs[status]));
		return B_ERROR;
	}

	//PRINT(("VerifyAudioOpen\n"));
	status = stream->card->pEG->VerifyAudioOpen(stream->pipe);
	if (status != ECHOSTATUS_OK) {
		PRINT(("echo_stream_set_audioparms : VerifyAudioOpen failed\n"));
		PRINT(("  status: %s \n", pStatusStrs[status]));
		return B_ERROR;
	}

	if (bitsPerSample == 24)
		bitsPerSample = 32;

	if ((stream->channels == channels)
		&& (stream->bitsPerSample == bitsPerSample)
		&& (stream->sample_rate == sample_rate))
		return B_OK;

	format_params.wBitsPerSample = bitsPerSample;
	format_params.byDataAreBigEndian = 0;
	format_params.byMonoToStereo = 0;
	format_params.wDataInterleave = channels == 1 ? 1 : 2;

	status = stream->card->pEG->QueryAudioFormat(stream->pipe, &format_params);
	if (status != ECHOSTATUS_OK) {
		PRINT(("echo_stream_set_audioparms : bad format when querying\n"));
		PRINT(("  status: %s \n", pStatusStrs[status]));
		return B_ERROR;
	}

	status = stream->card->pEG->SetAudioFormat(stream->pipe, &format_params);
	if (status != ECHOSTATUS_OK) {
		PRINT(("echo_stream_set_audioparms : bad format when setting\n"));
		PRINT(("  status: %s \n", pStatusStrs[status]));
		return B_ERROR;
	}

	/* XXXX : setting sample rate is global in this driver */
	status = stream->card->pEG->QueryAudioSampleRate(sample_rate);
	if (status != ECHOSTATUS_OK) {
		PRINT(("echo_stream_set_audioparms : bad sample rate when querying\n"));
		PRINT(("  status: %s \n", pStatusStrs[status]));
		return B_ERROR;
	}

	/* XXXX : setting sample rate is global in this driver */
	status = stream->card->pEG->SetAudioSampleRate(sample_rate);
	if (status != ECHOSTATUS_OK) {
		PRINT(("echo_stream_set_audioparms : bad sample rate when setting\n"));
		PRINT(("  status: %s \n", pStatusStrs[status]));
		return B_ERROR;
	}

	if (stream->buffer)
		echo_mem_free(stream->card, stream->buffer->log_base);

	stream->bitsPerSample = bitsPerSample;
	stream->sample_rate = sample_rate;
	stream->channels = channels;

	sample_size = stream->bitsPerSample / 8;
	frame_size = sample_size * stream->channels;

	stream->buffer = echo_mem_alloc(stream->card,
		stream->bufframes * frame_size * stream->bufcount);

	stream->trigblk = 1;
	stream->blkmod = stream->bufcount;
	stream->blksize = stream->bufframes * frame_size;

	CDaffyDuck *duck = stream->card->pEG->GetDaffyDuck(stream->pipe);
	if (duck == NULL) {
		PRINT(("echo_stream_set_audioparms : Could not get daffy duck pointer\n"));
		return B_ERROR;
	}

	uint32 dwNumFreeEntries = 0;

	for (i = 0; i < stream->bufcount; i++) {
		duck->AddMapping(((uint32)stream->buffer->phy_base) +
			i * stream->blksize, stream->blksize, 0, TRUE, dwNumFreeEntries);
	}

	duck->Wrap();

	if (stream->card->pEG->GetAudioPositionPtr(stream->pipe, stream->position)!=ECHOSTATUS_OK) {
		PRINT(("echo_stream_set_audioparms : Could not get audio position ptr\n"));
		return B_ERROR;
	}

	return B_OK;
}


status_t
echo_stream_get_nth_buffer(echo_stream *stream, uint8 chan, uint8 buf,
	char** buffer, size_t *stride)
{
	uint8 			sample_size, frame_size;
	LOG(("echo_stream_get_nth_buffer\n"));

	sample_size = stream->bitsPerSample / 8;
	frame_size = sample_size * stream->channels;

	*buffer = (char*)stream->buffer->log_base + (buf * stream->bufframes * frame_size)
		+ chan * sample_size;
	*stride = frame_size;

	return B_OK;
}


static uint32
echo_stream_curaddr(echo_stream *stream)
{
	uint32 addr = B_LENDIAN_TO_HOST_INT32(*stream->position);
//	TRACE(("stream_curaddr %p, phy_base %p\n", addr));
	return (addr / stream->blksize) % stream->blkmod;
}


void
echo_stream_start(echo_stream *stream, void (*inth) (void *), void *inthparam)
{
	LOG(("echo_stream_start\n"));
	ECHOSTATUS status;

	stream->inth = inth;
	stream->inthparam = inthparam;

	stream->state |= ECHO_STATE_STARTED;

	status = stream->card->pEG->Start(stream->pipe);
	if (status!=ECHOSTATUS_OK) {
		PRINT(("echo_stream_start : Could not start the pipe %s\n", pStatusStrs[status]));
	}
}


void
echo_stream_halt(echo_stream *stream)
{
	LOG(("echo_stream_halt\n"));
	ECHOSTATUS status;

	stream->state &= ~ECHO_STATE_STARTED;

	status = stream->card->pEG->Stop(stream->pipe);
	if (status!=ECHOSTATUS_OK) {
		PRINT(("echo_stream_halt : Could not stop the pipe %s\n", pStatusStrs[status]));
	}
}


echo_stream *
echo_stream_new(echo_dev *card, uint8 use, uint32 bufframes, uint8 bufcount)
{
	echo_stream *stream;
	cpu_status status;
	LOG(("echo_stream_new\n"));

	stream = (echo_stream *) malloc(sizeof(echo_stream));
	if (stream == NULL)
		return (NULL);
	stream->card = card;
	stream->use = use;
	stream->state = 0;
	stream->bitsPerSample = 0;
	stream->sample_rate = 0;
	stream->channels = 0;
	stream->bufframes = bufframes;
	stream->bufcount = bufcount;
	stream->inth = NULL;
	stream->inthparam = NULL;
	stream->buffer = NULL;
	stream->blksize = 0;
	stream->trigblk = 0;
	stream->blkmod = 0;

	stream->pipe = -1;

	stream->frames_count = 0;
	stream->real_time = 0;
	stream->buffer_cycle = 0;
	stream->update_needed = false;

	status = lock();
	LIST_INSERT_HEAD((&card->streams), stream, next);
	unlock(status);

	return stream;
}


void
echo_stream_delete(echo_stream *stream)
{
	cpu_status status;
	ECHOGALS_CLOSEAUDIOPARAMETERS close_params;
	LOG(("echo_stream_delete\n"));

	echo_stream_halt(stream);

	if (stream->pipe >= 0) {
		close_params.wPipeIndex = stream->pipe;
		status = stream->card->pEG->CloseAudio(&close_params);
		if (status != ECHOSTATUS_OK && status != ECHOSTATUS_CHANNEL_NOT_OPEN) {
			PRINT(("echo_stream_set_audioparms : CloseAudio failed\n"));
			PRINT((" status: %s \n", pStatusStrs[status]));
		}
	}

	if (stream->buffer)
		echo_mem_free(stream->card, stream->buffer->log_base);

	status = lock();
	LIST_REMOVE(stream, next);
	unlock(status);

	free(stream);
}


/* Echo interrupt */

int32 echo_int(void *arg)
{
	echo_dev* card = (echo_dev*)arg;
	BOOL midiReceived;
	ECHOSTATUS err;
	echo_stream* stream;
	uint32 curblk;

	err = card->pEG->ServiceIrq(midiReceived);

	if (err != ECHOSTATUS_OK) {
		return B_UNHANDLED_INTERRUPT;
	}

#ifdef MIDI_SUPPORT
	if (midiReceived)
		release_sem_etc(card->midi.midi_ready_sem, 1, B_DO_NOT_RESCHEDULE);
#endif

	LIST_FOREACH(stream, &card->streams, next) {
		if ((stream->state & ECHO_STATE_STARTED) == 0 ||
			(stream->inth == NULL))
				continue;

		curblk = echo_stream_curaddr(stream);
		//TRACE(("echo_int stream %p at trigblk %lu at stream->trigblk %lu\n",
		//	   stream, curblk, stream->trigblk));
		if (curblk == stream->trigblk) {
			if (stream->inth)
				stream->inth(stream->inthparam);

			stream->trigblk++;
			stream->trigblk %= stream->blkmod;
		}
	}

	return B_INVOKE_SCHEDULER;
}

/* dumps card capabilities */
void
echo_dump_caps(echo_dev *card)
{
	PECHOGALS_CAPS caps = &card->caps;
	PRINT(("name: %s\n", caps->szName));
	PRINT(("out pipes: %d, in pipes: %d, out busses: %d, in busses: %d, out midi: %d, in midi: %d\n",
		caps->wNumPipesOut, caps->wNumPipesIn, caps->wNumBussesOut, caps->wNumBussesIn, caps->wNumMidiOut, caps->wNumMidiIn));

}


/* detect presence of our hardware */
status_t
init_hardware(void)
{
#ifdef CARDBUS
	return B_OK;
#else
	int ix = 0;
	pci_info info;
	status_t err = ENODEV;

	LOG_CREATE();

	PRINT(("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) {

		ushort card_type = info.u.h0.subsystem_id & 0xfff0;

		if (info.vendor_id == VENDOR_ID
			&& ((info.device_id == DEVICE_ID_56301)
			|| (info.device_id == DEVICE_ID_56361))
			&& (info.u.h0.subsystem_vendor_id == SUBVENDOR_ID)
			&& (
#ifdef ECHOGALS_FAMILY
			(card_type == DARLA)
			|| (card_type == GINA)
			|| (card_type == LAYLA)
			|| (card_type == DARLA24)
#endif
#ifdef ECHO24_FAMILY
			(card_type == GINA24)
			|| (card_type == LAYLA24)
			|| (card_type == MONA)
			|| (card_type == MIA)
#endif
#ifdef INDIGO_FAMILY
			(card_type == INDIGO)
			|| (card_type == INDIGO_IO)
			|| (card_type == INDIGO_DJ)
#endif
#ifdef ECHO3G_FAMILY
			(card_type == ECHO3G)
#endif
			 )) {
			err = B_OK;
		}
		ix++;
	}

	put_module(B_PCI_MODULE_NAME);

	if (err != B_OK) {
		PRINT(("no card found\n"));
	}

	return err;
#endif
}


status_t
init_driver(void)
{
	PRINT(("init_driver()\n"));

#ifdef CARDBUS
	// Get card services client module
	if (get_module(CB_ENABLER_MODULE_NAME, (module_info **)&cbemi) != B_OK) {
		dprintf(DRIVER_NAME ": cardbus enabler module error\n");
		return B_ERROR;
	}
	// Create the devices lock
	device_lock = create_sem(1, DRIVER_NAME " device");
	if (device_lock < B_OK) {
		dprintf(DRIVER_NAME ": create device semaphore error 0x%.8x\n", device_lock);
		put_module(CB_ENABLER_MODULE_NAME);
		return B_ERROR;
	}
	// Register driver
	cbemi->register_driver(DRIVER_NAME, descriptors, COUNT_DESCRIPTOR);
	cbemi->install_notify(DRIVER_NAME, &cardbus_hooks);
	LIST_INIT(&(devices));
	return B_OK;
#else
	int ix = 0;

	pci_info info;
	status_t err;
	num_cards = 0;

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

	while ((*pci->get_nth_pci_info)(ix++, &info) == B_OK) {
		ushort card_type = info.u.h0.subsystem_id & 0xfff0;

		if (info.vendor_id == VENDOR_ID
			&& ((info.device_id == DEVICE_ID_56301)
			|| (info.device_id == DEVICE_ID_56361))
			&& (info.u.h0.subsystem_vendor_id == SUBVENDOR_ID)
			&& (
#ifdef ECHOGALS_FAMILY
			(card_type == DARLA)
			|| (card_type == GINA)
			|| (card_type == LAYLA)
			|| (card_type == DARLA24)
#endif
#ifdef ECHO24_FAMILY
			(card_type == GINA24)
			|| (card_type == LAYLA24)
			|| (card_type == MONA)
			|| (card_type == MIA)
#endif
#ifdef INDIGO_FAMILY
			(card_type == INDIGO)
			|| (card_type == INDIGO_IO)
			|| (card_type == INDIGO_DJ)
#endif
#ifdef ECHO3G_FAMILY
			(card_type == ECHO3G)
#endif
			)) {

			if (num_cards == NUM_CARDS) {
				PRINT(("Too many " DRIVER_NAME " cards installed!\n"));
				break;
			}
			memset(&cards[num_cards], 0, sizeof(echo_dev));
			cards[num_cards].info = info;
			cards[num_cards].type = card_type;
#ifdef __HAIKU__
			if ((err = (*pci->reserve_device)(info.bus, info.device, info.function,
				DRIVER_NAME, &cards[num_cards])) < B_OK) {
				dprintf("%s: failed to reserve_device(%d, %d, %d,): %s\n",
					DRIVER_NAME, info.bus, info.device, info.function,
					strerror(err));
				continue;
			}
#endif
			if (echo_setup(&cards[num_cards])) {
				PRINT(("Setup of " DRIVER_NAME " %" B_PRId32 " failed\n", num_cards + 1));
#ifdef __HAIKU__
				(*pci->unreserve_device)(info.bus, info.device, info.function,
					DRIVER_NAME, &cards[num_cards]);
#endif
			}
			else {
				num_cards++;
			}
		}
	}
	if (!num_cards) {
		PRINT(("no cards\n"));
		put_module(B_PCI_MODULE_NAME);
		PRINT(("no suitable cards found\n"));
		return ENODEV;
	}

	return B_OK;
#endif
}


#ifndef CARDBUS
static void
make_device_names(echo_dev * card)
{
#ifdef MIDI_SUPPORT
	sprintf(card->midi.name, "midi/" DRIVER_NAME "/%ld", card-cards + 1);
	names[num_names++] = card->midi.name;
#endif
	sprintf(card->name, "audio/hmulti/" DRIVER_NAME "/%ld", card-cards + 1);
	names[num_names++] = card->name;

	names[num_names] = NULL;
}
#else

status_t
cardbus_device_added(pci_info *info, void **cookie) {
	echo_dev 			* card, *dev;
	uint32				index;
	char				buffer[32];

	LOG(("cardbus_device_added at %.2d:%.2d:%.2d\n", info->bus, info->device, info->function));
	// Allocate cookie
	if (!(*cookie = card = (echo_dev *)malloc(sizeof(echo_dev)))) {
		return B_NO_MEMORY;
	}
	// Clear cookie
	memset(card, 0, sizeof(echo_dev));
	// Initialize cookie
	card->info = *info;
	card->plugged = true;
	card->index = 0;

	LIST_FOREACH(dev, &devices, next) {
		if (dev->index == card->index) {
			card->index++;
			dev = LIST_FIRST(&devices);
		}
	}

	// Format device name
	sprintf(card->name, "audio/hmulti/" DRIVER_NAME "/%ld", card->index);
	// Lock the devices
	acquire_sem(device_lock);
	LIST_INSERT_HEAD((&devices), card, next);
	// Unlock the devices
	release_sem(device_lock);

	echo_setup(card);
	return B_OK;
}


// cardbus_device_removed - handle cardbus device removal.
// status : OK
void
cardbus_device_removed(void *cookie)
{
	echo_dev		*card = (echo_dev *) cookie;

	LOG((": cardbus_device_removed\n"));
	// Check
	if (card == NULL) {
		LOG((": null device 0x%.8x\n", card));
		return;
	}

	echo_shutdown(card);

	// Lock the devices
	acquire_sem(device_lock);
	// Finalize
	card->plugged = false;
	// Check if the device is opened
	if (card->opened) {
		LOG(("device 0x%.8x %s still in use\n", card, card->name));
	} else {
		LOG(("free device 0x%.8x %s\n", card, card->name));
		LIST_REMOVE(card, next);
		free(card);
	}
	// Unlock the devices
	release_sem(device_lock);
}

#endif


static status_t
echo_setup(echo_dev* card)
{
	unsigned char cmd;
	const char* name;

	PRINT(("echo_setup(%p)\n", card));

#ifndef CARDBUS
	(*pci->write_pci_config)(card->info.bus, card->info.device,
		card->info.function, PCI_latency, 1, 0xc0 );

	make_device_names(card);
#endif
	card->bmbar = card->info.u.h0.base_registers[0];
	card->irq = card->info.u.h0.interrupt_line;

	card->area_bmbar = map_mem(&card->log_bmbar, card->bmbar,
		card->info.u.h0.base_register_sizes[0], DRIVER_NAME" bmbar io");
	if (card->area_bmbar <= B_OK) {
		LOG(("mapping of bmbar io failed, error = %#x\n",card->area_bmbar));
		goto err5;
	}
	LOG(("mapping of bmbar: area %#x, phys %#x, log %#x\n", card->area_bmbar,
		card->bmbar, card->log_bmbar));

	card->pOSS = new COsSupport(card->info.device_id, card->info.revision);
	if (card->pOSS == NULL)
		goto err4;

	switch (card->type) {
#ifdef ECHOGALS_FAMILY
		case DARLA:
			card->pEG = new CDarla(card->pOSS);
			name = "Echo Darla";
			break;
		case GINA:
			card->pEG = new CGina(card->pOSS);
			name = "Echo Gina";
			break;
		case LAYLA:
			card->pEG = new CLayla(card->pOSS);
			name = "Echo Layla";
			break;
		case DARLA24:
			card->pEG = new CDarla24(card->pOSS);
			name = "Echo Darla24";
			break;
#endif
#ifdef ECHO24_FAMILY
		case GINA24:
			card->pEG = new CGina24(card->pOSS);
			name = "Echo Gina24";
			break;
		case LAYLA24:
			card->pEG = new CLayla24(card->pOSS);
			name = "Echo Layla24";
			break;
		case MONA:
			card->pEG = new CMona(card->pOSS);
			name = "Echo Mona";
			break;
		case MIA:
			card->pEG = new CMia(card->pOSS);
			name = "Echo Mia";
			break;
#endif
#ifdef INDIGO_FAMILY
		case INDIGO:
			card->pEG = new CIndigo(card->pOSS);
			name = "Echo Indigo";
			break;
		case INDIGO_IO:
			card->pEG = new CIndigoIO(card->pOSS);
			name = "Echo IndigoIO";
			break;
		case INDIGO_DJ:
			card->pEG = new CIndigoDJ(card->pOSS);
			name = "Echo IndigoDJ";
			break;
#endif
#ifdef ECHO3G_FAMILY
		case ECHO3G:
			card->pEG = new C3g(card->pOSS);
			name = "Echo 3g";
			break;
#endif
		default:
			PRINT(("card type 0x%x not supported by " DRIVER_NAME "\n",
				card->type));
			name = "Unknown";
	}

	if (card->pEG == NULL)
		goto err2;

#ifndef CARDBUS
	cmd = (*pci->read_pci_config)(card->info.bus, card->info.device,
		card->info.function, PCI_command, 2);
	PRINT(("PCI command before: %x\n", cmd));
	(*pci->write_pci_config)(card->info.bus, card->info.device,
		card->info.function, PCI_command, 2, cmd | PCI_command_io);
	cmd = (*pci->read_pci_config)(card->info.bus, card->info.device,
		card->info.function, PCI_command, 2);
	PRINT(("PCI command after: %x\n", cmd));
#endif

	card->pEG->AssignResources(card->log_bmbar, name);

	ECHOSTATUS status;
	status = card->pEG->InitHw();
	if (status != ECHOSTATUS_OK)
		goto err3;

	card->pEG->GetCapabilities(&card->caps);

	/* Init streams list */
	LIST_INIT(&(card->streams));

	/* Init mems list */
	LIST_INIT(&(card->mems));

#ifdef MIDI_SUPPORT
	card->midi.midi_ready_sem = create_sem(0, "midi sem");
#endif

	PRINT(("installing interrupt : %x\n", card->irq));
	status = install_io_interrupt_handler(card->irq, echo_int, card, 0);
	if (status != B_OK) {
		PRINT(("failed to install interrupt\n"));
		goto err2;
	}

	PRINT(("echo_setup done\n"));

	echo_dump_caps(card);

#ifdef ECHO3G_FAMILY
	if (card->type == ECHO3G) {
		strlcpy(card->caps.szName, ((C3g*)card->pEG)->Get3gBoxName(),
			ECHO_MAXNAMELEN);
	}
#endif

	status = card->pEG->OpenMixer(card->mixer);
	if (status != ECHOSTATUS_OK) {
		PRINT(("failed to open mixer\n"));
		goto err1;
	}

	return B_OK;

err1:
	remove_io_interrupt_handler(card->irq, echo_int, card);
err2:
#ifdef MIDI_SUPPORT
	delete_sem(card->midi.midi_ready_sem);
#endif
err3:
	delete card->pEG;
err4:
	delete card->pOSS;
err5:
	delete_area(card->area_bmbar);
	return B_ERROR;
}

static void
echo_shutdown(echo_dev *card)
{
	ECHOSTATUS status;

	PRINT(("shutdown(%p)\n", card));
	status = card->pEG->CloseMixer(card->mixer);
	if (status != ECHOSTATUS_OK)
		PRINT(("echo_shutdown: error when CloseMixer\n"));

	remove_io_interrupt_handler(card->irq, echo_int, card);

#ifdef MIDI_SUPPORT
	delete_sem(card->midi.midi_ready_sem);
#endif

	delete card->pEG;
	delete card->pOSS;

	delete_area(card->area_bmbar);
}



void
uninit_driver(void)
{
	PRINT(("uninit_driver()\n"));

#ifdef CARDBUS
	echo_dev			*dev;

	LIST_FOREACH(dev, &devices, next) {
		echo_shutdown(dev);
	}
	put_module(CB_ENABLER_MODULE_NAME);
#else
	int ix, cnt = num_cards;
	num_cards = 0;
	for (ix=0; ix<cnt; ix++) {
		echo_shutdown(&cards[ix]);
#ifdef __HAIKU__
		(*pci->unreserve_device)(cards[ix].info.bus,
			cards[ix].info.device, cards[ix].info.function,
			DRIVER_NAME, &cards[ix]);
#endif
	}

	memset(&cards, 0, sizeof(cards));
	put_module(B_PCI_MODULE_NAME);
#endif
}


const char **
publish_devices(void)
{
#ifdef CARDBUS
	echo_dev			*dev;
	int			ix = 0;

	// Lock the devices
	acquire_sem(device_lock);
	// Loop
	LIST_FOREACH(dev, &devices, next) {
		if (dev->plugged == true) {
			names[ix] = dev->name;
			ix++;
		}
	}
	names[ix] = NULL;
	release_sem(device_lock);
#else
	int ix = 0;
	PRINT(("publish_devices()\n"));

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


device_hooks *
find_device(const char * name)
{
#ifdef CARDBUS
	echo_dev *dev;
	LIST_FOREACH(dev, &devices, next) {
		if (!strcmp(dev->name, name)) {
			return &multi_hooks;
		}
	}

#else
	int ix;

	PRINT(("find_device(%s)\n", name));

	for (ix=0; ix<num_cards; ix++) {
#ifdef MIDI_SUPPORT
		if (!strcmp(cards[ix].midi.name, name)) {
			return &midi_hooks;
		}
#endif
		if (!strcmp(cards[ix].name, name)) {
			return &multi_hooks;
		}
	}
#endif
	PRINT(("find_device(%s) failed\n", name));
	return NULL;
}

int32	api_version = B_CUR_DRIVER_API_VERSION;