/*
	Copyright (c) 2002, Thomas Kurschel
	

	Part of Radeon accelerant
		
	Main init/uninit functions
*/


#include "GlobalData.h"
#include "generic.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <malloc.h>
#include "CP.h"


// init data used by both primary and cloned accelerant
//	the_fd - file descriptor of kernel driver
//	accelerant_is_clone - if true, this is a cloned accelerant
static status_t init_common( int the_fd, bool accelerant_is_clone ) 
{
	status_t result;
	radeon_get_private_data gpd;
	
	SHOW_FLOW0( 3, "" );

	ai = malloc( sizeof( *ai ));
	if( ai == NULL )
		return B_NO_MEMORY;
		
	memset( ai, 0, sizeof( *ai ));
	
	ai->accelerant_is_clone = accelerant_is_clone;
	ai->fd = the_fd;
	
	// get basic info from driver
	gpd.magic = RADEON_PRIVATE_DATA_MAGIC;

	result = ioctl( ai->fd, RADEON_GET_PRIVATE_DATA, &gpd, sizeof(gpd) );
	if (result != B_OK) goto err;

	ai->virtual_card_area = clone_area( "Radeon virtual card", (void **)&ai->vc, B_ANY_ADDRESS,
		B_READ_AREA | B_WRITE_AREA, gpd.virtual_card_area );
	if( ai->virtual_card_area < 0 ) {
		result = ai->virtual_card_area;
		goto err;
	}
	ai->shared_info_area = clone_area( "Radeon shared info", (void **)&ai->si, B_ANY_ADDRESS,
		B_READ_AREA | B_WRITE_AREA, gpd.shared_info_area );
	if( ai->shared_info_area < 0 ) {
		result = ai->shared_info_area;
		goto err2;
	}
	
	ai->regs_area = clone_area( "Radeon regs area", (void **)&ai->regs, B_ANY_ADDRESS,
		B_READ_AREA | B_WRITE_AREA, ai->si->regs_area );
	if( ai->regs_area < 0 ) {
		result = ai->regs_area;
		goto err3;
	}
	
//rud:
	if( ai->si->memory[mt_PCI].area > 0 ) {
		ai->mapped_memory[mt_PCI].area = clone_area( "Radeon PCI GART area", 
			(void **)&ai->mapped_memory[mt_PCI].data, B_ANY_ADDRESS,
			B_READ_AREA | B_WRITE_AREA, ai->si->memory[mt_PCI].area );
		if( ai->mapped_memory[mt_PCI].area < 0 ) {
			result = ai->mapped_memory[mt_PCI].area;
			goto err4;
		}
	}
	
	if( ai->si->memory[mt_AGP].area > 0 ) {
		ai->mapped_memory[mt_AGP].area = clone_area( "Radeon AGP GART area", 
			(void **)&ai->mapped_memory[mt_AGP].data, B_ANY_ADDRESS,
			B_READ_AREA | B_WRITE_AREA, ai->si->memory[mt_AGP].area );
		if( ai->mapped_memory[mt_AGP].area < 0 ) {
			result = ai->mapped_memory[mt_AGP].area;
			goto err5;
		}
	}

	ai->mapped_memory[mt_nonlocal] = ai->mapped_memory[ai->si->nonlocal_type];
	ai->mapped_memory[mt_local].data = ai->si->local_mem;
	
	return B_OK;

err5:
	if( ai->mapped_memory[mt_PCI].area > 0 )
		delete_area( ai->mapped_memory[mt_PCI].area );
err4:
	delete_area( ai->regs_area );
err3:
	delete_area( ai->shared_info_area );
err2:
	delete_area( ai->virtual_card_area );
err:
	free( ai );
	return result;
}

// clean up data common to both primary and cloned accelerant
static void uninit_common( void )
{
	if( !ai->accelerant_is_clone ) {
		if ( ai->si->acc_dma ) 
			Radeon_FreeVirtualCardStateBuffer( ai );

		// the last accelerant should must wait for the card to become quite,
		// else some nasty command could lunger in some FIFO
		Radeon_WaitForIdle( ai, false );
	}

	if( ai->mapped_memory[mt_AGP].area > 0 )
		delete_area( ai->mapped_memory[mt_AGP].area );
	if( ai->mapped_memory[mt_PCI].area > 0 )
		delete_area( ai->mapped_memory[mt_PCI].area );
	delete_area( ai->regs_area );
	delete_area( ai->shared_info_area );
	delete_area( ai->virtual_card_area );
	
	ai->regs_area = ai->shared_info_area = ai->virtual_card_area = 0;
	
	ai->regs = 0;
	ai->si = 0;
	ai->vc = 0;
	
	// close the file handle ONLY if we're the clone
	// (this is what Be tells us ;)
	if( ai->accelerant_is_clone ) 
		close( ai->fd );
	
	free( ai );
}

// public function: init primary accelerant
//	the_fd - file handle of kernel driver
status_t INIT_ACCELERANT( int the_fd ) 
{
	shared_info *si;
	virtual_card *vc;
	status_t result;
	
	SHOW_FLOW0( 3, "" );
	
	result = init_common( the_fd, 0 );
	if (result != B_OK) 
		goto err;

	si = ai->si;
	vc = ai->vc;

	// init Command Processor
	/*result = Radeon_InitCP( ai );
	if( result != B_OK )
		goto err2;*/
		
	// this isn't the best place, but has to be done sometime	
	Radeon_ReadSettings( vc );

	// establish connection to TV-Out unit
	Radeon_DetectTVOut( ai );

	// get all possible information about connected display devices	
	Radeon_DetectDisplays( ai );

	// create list of supported modes
	result = Radeon_CreateModeList( si );
	if (result != B_OK) 
		goto err3;

	/* init the shared semaphore */
	(void)INIT_BEN( si->engine.lock, "Radeon engine" );

	// init engine sync token
	// (count of issued parameters or commands)
	si->engine.last_idle = si->engine.count = 0;
	// set last written count to be very old, so it must be written on first use
	// (see writeSyncToken)
	si->engine.written = -1;
	
	// init overlay
	si->overlay_mgr.token = 0;
	si->overlay_mgr.inuse = 0;
	
	// mark overlay as inactive
	si->active_overlay.crtc_idx = -1;
	si->pending_overlay.crtc_idx = -1;
	
	// reset list of allocated overlays
	vc->overlay_buffers = NULL;
	
	// mark engine as having no state
	//si->cp.active_state_buffer = -1;
	
	if ( ai->si->acc_dma )
		Radeon_AllocateVirtualCardStateBuffer( ai );

	// everything else is initialized upon set_display_mode
	return B_OK;

err3:
//err2:
	uninit_common();
err:
	return result;
}


// public function: return size of clone info
ssize_t ACCELERANT_CLONE_INFO_SIZE( void )
{
	SHOW_FLOW0( 0, "" );

	// clone info is device name, so return its maximum size
	return MAX_RADEON_DEVICE_NAME_LENGTH;
}


// public function: return clone info
//	data - buffer to contain info (allocated by caller)
void GET_ACCELERANT_CLONE_INFO( void *data ) 
{
	radeon_device_name dn;
	status_t result;

	SHOW_FLOW0( 0, "" );

	// clone info is device name - ask device driver
	dn.magic = RADEON_PRIVATE_DATA_MAGIC;
	dn.name = (char *)data;
	
	result = ioctl( ai->fd, RADEON_DEVICE_NAME, &dn, sizeof(dn) );
}

// public function: init cloned accelerant
//	data - clone info from get_accelerant_clone_info
status_t CLONE_ACCELERANT( void *data ) 
{
	status_t result;
	char path[MAXPATHLEN];
	int fd;
	
	SHOW_FLOW0( 0, "" );

	// create full device name
	strcpy(path, "/dev/");
	strcat(path, (const char *)data);

	// open device; according to Be, permissions aren't important
	// this will probably change once access right are checked properly
	fd = open(path, B_READ_WRITE);
	if( fd < 0 )
		return errno;

	result = init_common( fd, 1 );
	if( result != B_OK )
		goto err1;

	// get (cloned) copy of supported display modes
	result = ai->mode_list_area = clone_area(
		"Radeon cloned display_modes", (void **)&ai->mode_list,
		B_ANY_ADDRESS, B_READ_AREA, ai->si->mode_list_area );
	if (result < B_OK) 
		goto err2;

	return B_OK;

err2:
	uninit_common();
err1:
	close( fd );
	return result;
}

// public function: uninit primary or cloned accelerant
void UNINIT_ACCELERANT( void )
{
	// TBD:
	// we should put accelerator into stable state first -
	// on my Laptop, you never can boot Windows/Linux after shutting
	// down BeOS; if both ports have been used, even the BIOS screen
	// is completely messed up
	
	SHOW_FLOW0( 0, "" );

	// cloned accelerants have mode_list cloned, so deleting is OK
	// primary accelerant owns mode list, so deleting is OK as well
	delete_area( ai->mode_list_area );
	ai->mode_list = 0;

	uninit_common();
}

// public function: get some info about graphics card
status_t GET_ACCELERANT_DEVICE_INFO( accelerant_device_info *di )
{
	SHOW_FLOW0( 0, "" );

	// is there anyone using it?
	
	// TBD: everything apart from memsize
	di->version = B_ACCELERANT_VERSION;
	strcpy( di->name, "Radeon" );
	strcpy( di->chipset, "Radeon" );
	strcpy( di->serial_no, "None" );
	
	di->memory = ai->si->memory[mt_local].size;
	
	// TBD: is max PLL speed really equal to max DAC speed?
	di->dac_speed = ai->si->pll.max_pll_freq;
	
	return B_OK;
}