/*
 * Copyright 2009, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *	Jérôme Duval (korli@users.berlios.de)
 */


#include "driver.h"

#define ALIGN(size, align)		(((size) + align - 1) & ~(align - 1))
#define PAGE_ALIGN(size)	(((size) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1))

#define STREAM_CMD			0x0		/* Command */
#define STREAM_STATUS			0x1		/* IRQ Status */
#define STREAM_PRD			0x4		/* PRD Table Address */

static const struct {
	uint32 multi_rate;
	uint32 rate;
} kRates[] = {
	{B_SR_8000, 8000},
	{B_SR_11025, 11025},
	{B_SR_16000, 16000},
	{B_SR_22050, 22050},
	{B_SR_32000, 32000},
	{B_SR_44100, 44100},
	{B_SR_48000, 48000},
	{B_SR_88200, 88200},
	{B_SR_96000, 96000},
	{B_SR_176400, 176400},
	{B_SR_192000, 192000},
};

static int
geode_codec_wait(geode_controller *controller)
{
	int i;

#define GCSCAUDIO_WAIT_READY_CODEC_TIMEOUT	500
	for (i = GCSCAUDIO_WAIT_READY_CODEC_TIMEOUT; (i >= 0)
	    && (controller->Read32(ACC_CODEC_CNTL) & ACC_CODEC_CNTL_CMD_NEW); i--)
		snooze(10);

	return (i < 0);
}

uint16
geode_codec_read(geode_controller *controller, uint8 regno)
{
	int i;
	uint32 v;
	ASSERT(regno >= 0);

	controller->Write32(ACC_CODEC_CNTL,
		ACC_CODEC_CNTL_READ_CMD | ACC_CODEC_CNTL_CMD_NEW |
		ACC_CODEC_REG2ADDR(regno));

	if (geode_codec_wait(controller) != B_OK) {
		dprintf("codec busy (2)\n");
		return 0xffff;
	}

#define GCSCAUDIO_READ_CODEC_TIMEOUT	50
	for (i = GCSCAUDIO_READ_CODEC_TIMEOUT; i >= 0; i--) {
		v = controller->Read32(ACC_CODEC_STATUS);
		if ((v & ACC_CODEC_STATUS_STS_NEW) &&
		    (ACC_CODEC_ADDR2REG(v) == regno))
			break;

		snooze(10);
	}

	if (i < 0) {
		dprintf("codec busy (3)\n");
		return 0xffff;
	}

	return v;
}

void
geode_codec_write(geode_controller *controller, uint8 regno, uint16 value)
{
	ASSERT(regno >= 0);

	controller->Write32(ACC_CODEC_CNTL,
	    ACC_CODEC_CNTL_WRITE_CMD |
	    ACC_CODEC_CNTL_CMD_NEW |
	    ACC_CODEC_REG2ADDR(regno) |
	    (value & ACC_CODEC_CNTL_CMD_DATA_MASK));

	if (geode_codec_wait(controller) != B_OK) {
		dprintf("codec busy (4)\n");
	}
}


//! Called with interrupts off
static void
stream_handle_interrupt(geode_controller* controller, geode_stream* stream)
{
	uint8 status;
	uint32 position, bufferSize;

	if (!stream->running)
		return;

	status = stream->Read8(STREAM_STATUS);

	if (status & ACC_BMx_STATUS_BM_EOP_ERR) {
		dprintf("geode: stream status bus master error\n");
	}
	if (status & ACC_BMx_STATUS_EOP) {
		dprintf("geode: stream status end of page\n");
	}

	position = controller->Read32(ACC_BM0_PNTR + stream->dma_offset);
	bufferSize = ALIGN(stream->sample_size * stream->num_channels * stream->buffer_length, 128);

	// Buffer Completed Interrupt
	acquire_spinlock(&stream->lock);

	stream->real_time = system_time();
	stream->frames_count += stream->buffer_length;
	stream->buffer_cycle = 1 - (position / (bufferSize + 1)); // added 1 to avoid having 2

	release_spinlock(&stream->lock);

	release_sem_etc(stream->buffer_ready_sem, 1, B_DO_NOT_RESCHEDULE);
}


static int32
geode_interrupt_handler(geode_controller* controller)
{
	uint16 intr = controller->Read16(ACC_IRQ_STATUS);
	if (intr == 0)
		return B_UNHANDLED_INTERRUPT;

	for (uint32 index = 0; index < GEODE_MAX_STREAMS; index++) {
		if (controller->streams[index]
			&& (intr & controller->streams[index]->status) != 0) {
			stream_handle_interrupt(controller,
				controller->streams[index]);
		}
	}

	return B_HANDLED_INTERRUPT;
}


static status_t
reset_controller(geode_controller* controller)
{
	controller->Write32(ACC_CODEC_CNTL, ACC_CODEC_CNTL_LNK_WRM_RST
	    | ACC_CODEC_CNTL_CMD_NEW);

	if (geode_codec_wait(controller) != B_OK) {
		dprintf("codec reset busy (1)\n");
	}

	// stop streams

	// stop DMA

	// reset DMA position buffer

	return B_OK;
}

//	#pragma mark - public stream functions


void
geode_stream_delete(geode_stream* stream)
{
	if (stream->buffer_ready_sem >= B_OK)
		delete_sem(stream->buffer_ready_sem);

	if (stream->buffer_area >= B_OK)
		delete_area(stream->buffer_area);

	if (stream->buffer_descriptors_area >= B_OK)
		delete_area(stream->buffer_descriptors_area);

	free(stream);
}


geode_stream*
geode_stream_new(geode_controller* controller, int type)
{
	geode_stream* stream = (geode_stream*)calloc(1, sizeof(geode_stream));
	if (stream == NULL)
		return NULL;

	stream->buffer_ready_sem = B_ERROR;
	stream->buffer_area = B_ERROR;
	stream->buffer_descriptors_area = B_ERROR;
	stream->type = type;
	stream->controller = controller;

	switch (type) {
		case STREAM_PLAYBACK:
			stream->status = ACC_IRQ_STATUS_BM0_IRQ_STS;
			stream->offset = 0;
			stream->dma_offset = 0;
			stream->ac97_rate_reg = AC97_PCM_FRONT_DAC_RATE;
			break;

		case STREAM_RECORD:
			stream->status = ACC_IRQ_STATUS_BM1_IRQ_STS;
			stream->offset = 0x8;
			stream->dma_offset = 0x4;
			stream->ac97_rate_reg = AC97_PCM_L_R_ADC_RATE;
			break;

		default:
			dprintf("%s: Unknown stream type %d!\n", __func__, type);
			free(stream);
			stream = NULL;
	}

	controller->streams[controller->num_streams++] = stream;
	return stream;
}


/*!	Starts a stream's DMA engine, and enables generating and receiving
	interrupts for this stream.
*/
status_t
geode_stream_start(geode_stream* stream)
{
	uint8 value;
	dprintf("geode_stream_start()\n");
	stream->buffer_ready_sem = create_sem(0, stream->type == STREAM_PLAYBACK
		? "geode_playback_sem" : "geode_record_sem");
	if (stream->buffer_ready_sem < B_OK)
		return stream->buffer_ready_sem;

	if (stream->type == STREAM_PLAYBACK)
		value = ACC_BMx_CMD_WRITE;
	else
		value = ACC_BMx_CMD_READ;

	stream->Write8(STREAM_CMD, value | ACC_BMx_CMD_BYTE_ORD_EL
		| ACC_BMx_CMD_BM_CTL_ENABLE);

	stream->running = true;
	return B_OK;
}


/*!	Stops the stream's DMA engine, and turns off interrupts for this
	stream.
*/
status_t
geode_stream_stop(geode_stream* stream)
{
	dprintf("geode_stream_stop()\n");
	stream->Write8(STREAM_CMD, ACC_BMx_CMD_BM_CTL_DISABLE);

	stream->running = false;
	delete_sem(stream->buffer_ready_sem);
	stream->buffer_ready_sem = -1;

	return B_OK;
}


status_t
geode_stream_setup_buffers(geode_stream* stream, const char* desc)
{
	uint32 bufferSize, alloc;
	uint32 index;
	physical_entry pe;
	struct acc_prd* bufferDescriptors;
	uint8* buffer;
	status_t rc;

	/* Clear previously allocated memory */
	if (stream->buffer_area >= B_OK) {
		delete_area(stream->buffer_area);
		stream->buffer_area = B_ERROR;
	}

	if (stream->buffer_descriptors_area >= B_OK) {
		delete_area(stream->buffer_descriptors_area);
		stream->buffer_descriptors_area = B_ERROR;
	}

	/* Calculate size of buffer (aligned to 128 bytes) */
	bufferSize = stream->sample_size * stream->num_channels
		* stream->buffer_length;
	bufferSize = ALIGN(bufferSize, 128);

	dprintf("geode: sample size %" B_PRIu32 ", num channels %" B_PRIu32 ", buffer length %"
			B_PRIu32 "\n",
		stream->sample_size, stream->num_channels, stream->buffer_length);

	/* Calculate total size of all buffers (aligned to size of B_PAGE_SIZE) */
	alloc = bufferSize * stream->num_buffers;
	alloc = PAGE_ALIGN(alloc);

	/* Allocate memory for buffers */
	stream->buffer_area = create_area("geode buffers", (void**)&buffer,
		B_ANY_KERNEL_ADDRESS, alloc, B_32_BIT_CONTIGUOUS,
		B_READ_AREA | B_WRITE_AREA);
		// TODO: The rest of the code doesn't deal correctly with physical
		// addresses > 4 GB, so we have to force 32 bit addresses here.
	if (stream->buffer_area < B_OK)
		return stream->buffer_area;

	/* Get the physical address of memory */
	rc = get_memory_map(buffer, alloc, &pe, 1);
	if (rc != B_OK) {
		delete_area(stream->buffer_area);
		return rc;
	}

	phys_addr_t bufferPhysicalAddress = pe.address;

	dprintf("%s(%s): Allocated %" B_PRId32 " bytes for %" B_PRIu32 " buffers\n", __func__, desc,
		alloc, stream->num_buffers);

	/* Store pointers (both virtual/physical) */
	for (index = 0; index < stream->num_buffers; index++) {
		stream->buffers[index] = buffer + (index * bufferSize);
		stream->physical_buffers[index] = bufferPhysicalAddress
			+ (index * bufferSize);
	}

	/* Now allocate BDL for buffer range */
	alloc = stream->num_buffers * sizeof(struct acc_prd) + 1;
	alloc = PAGE_ALIGN(alloc);

	stream->buffer_descriptors_area = create_area("geode buffer descriptors",
		(void**)&bufferDescriptors, B_ANY_KERNEL_ADDRESS, alloc,
		B_32_BIT_CONTIGUOUS, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA);
		// TODO: The rest of the code doesn't deal correctly with physical
		// addresses > 4 GB, so we have to force 32 bit addresses here.
	if (stream->buffer_descriptors_area < B_OK) {
		delete_area(stream->buffer_area);
		return stream->buffer_descriptors_area;
	}

	/* Get the physical address of memory */
	rc = get_memory_map(bufferDescriptors, alloc, &pe, 1);
	if (rc != B_OK) {
		delete_area(stream->buffer_area);
		delete_area(stream->buffer_descriptors_area);
		return rc;
	}

	stream->physical_buffer_descriptors = pe.address;

	dprintf("%s(%s): Allocated %" B_PRIu32 " bytes for %" B_PRIu32 " BDLEs\n", __func__, desc,
		alloc, stream->num_buffers);

	/* Setup buffer descriptor list (BDL) entries */
	for (index = 0; index < stream->num_buffers; index++, bufferDescriptors++) {
		bufferDescriptors->address = stream->physical_buffers[index];
		bufferDescriptors->ctrlsize = bufferSize | ACC_BMx_PRD_CTRL_EOP;
			// we want an interrupt after every buffer
	}
	bufferDescriptors->address = stream->physical_buffer_descriptors;
	bufferDescriptors->ctrlsize = ACC_BMx_PRD_CTRL_JMP;

	for (index = 0; index < sizeof(kRates) / sizeof(kRates[0]); index++) {
		if (kRates[index].multi_rate == stream->sample_rate) {
			stream->rate = kRates[index].rate;
			break;
		}
	}

	/* Configure stream registers */
	dprintf("IRA: %s: setup stream SR=%" B_PRIu32 "\n", __func__, stream->rate);

	stream->Write32(STREAM_PRD, stream->physical_buffer_descriptors);

	ac97_set_rate(stream->controller->ac97, stream->ac97_rate_reg, stream->rate);
	snooze(1000);
	return B_OK;
}


//	#pragma mark - public controller functions


/*! Setup hardware for use; detect codecs; etc */
status_t
geode_hw_init(geode_controller* controller)
{
	uint16 cmd;
	status_t status;

	cmd = (gPci->read_pci_config)(controller->pci_info.bus,
		controller->pci_info.device, controller->pci_info.function, PCI_command, 2);
	if (!(cmd & PCI_command_master)) {
		(gPci->write_pci_config)(controller->pci_info.bus,
			controller->pci_info.device, controller->pci_info.function,
				PCI_command, 2, cmd | PCI_command_master);
		dprintf("geode: enabling PCI bus mastering\n");
	}

	controller->nabmbar = controller->pci_info.u.h0.base_registers[0];

	/* Absolute minimum hw is online; we can now install interrupt handler */
	controller->irq = controller->pci_info.u.h0.interrupt_line;
	status = install_io_interrupt_handler(controller->irq,
		(interrupt_handler)geode_interrupt_handler, controller, 0);
	if (status != B_OK)
		goto error;

	/* Get controller into valid state */
	status = reset_controller(controller);
	if (status != B_OK) {
		dprintf("geode: reset_controller failed\n");
		goto reset_failed;
	}

	/* attach the codec */
	ac97_attach(&controller->ac97, (codec_reg_read)geode_codec_read,
		(codec_reg_write)geode_codec_write, controller,
		controller->pci_info.u.h0.subsystem_vendor_id,
		controller->pci_info.u.h0.subsystem_id);

	snooze(1000);

	controller->multi = (geode_multi*)calloc(1, sizeof(geode_multi));
        if (controller->multi == NULL)
                return B_NO_MEMORY;

	controller->playback_stream = geode_stream_new(controller, STREAM_PLAYBACK);
        controller->record_stream = geode_stream_new(controller, STREAM_RECORD);

	return B_OK;

reset_failed:
	remove_io_interrupt_handler(controller->irq,
		(interrupt_handler)geode_interrupt_handler, controller);
error:
	dprintf("geode: ERROR: %s(%" B_PRId32 ")\n", strerror(status), status);

	return status;
}


/*! Stop any activity */
void
geode_hw_stop(geode_controller* controller)
{
	int index;

	/* Stop all audio streams */
	for (index = 0; index < GEODE_MAX_STREAMS; index++) {
		if (controller->streams[index] && controller->streams[index]->running)
			geode_stream_stop(controller->streams[index]);
	}
}


/*! Free resources */
void
geode_hw_uninit(geode_controller* controller)
{
	if (controller == NULL)
		return;

	/* Stop all audio streams */
	geode_hw_stop(controller);

	reset_controller(controller);

	remove_io_interrupt_handler(controller->irq,
		(interrupt_handler)geode_interrupt_handler, controller);

	free(controller->multi);

	geode_stream_delete(controller->playback_stream);
        geode_stream_delete(controller->record_stream);

}