path: root/drivers/dsp/syslink/procmgr/processor.c

/*
 * processor.c
 *
 * Syslink driver support functions for TI OMAP processors.
 *
 * Copyright (C) 2009-2010 Texas Instruments, Inc.
 *
 * This package is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include <linux/types.h>
#include <linux/module.h>

/* Module level headers */
#include "procdefs.h"
#include "processor.h"



/* =========================================
 * Functions called by ProcMgr
 * =========================================
 */
/*
 * Function to attach to the Processor.
 *
 * This function calls into the specific Processor implementation
 * to attach to it.
 * This function is called from the ProcMgr attach function, and
 * hence is used to perform any activities that may be required
 * once the slave is powered up.
 * Depending on the type of Processor, this function may or may not
 * perform any activities.
 */
inline int processor_attach(void *handle,
				struct processor_attach_params *params)
{
	int retval = 0;
	struct processor_object *proc_handle =
				(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	BUG_ON(params == NULL);
	BUG_ON(proc_handle->proc_fxn_table.attach == NULL);

	proc_handle->boot_mode = params->params->boot_mode;
	retval = proc_handle->proc_fxn_table.attach(handle, params);

	if (proc_handle->boot_mode == PROC_MGR_BOOTMODE_BOOT)
		proc_handle->state = PROC_MGR_STATE_POWERED;
	else if (proc_handle->boot_mode == PROC_MGR_BOOTMODE_NOLOAD)
		proc_handle->state = PROC_MGR_STATE_LOADED;
	else if (proc_handle->boot_mode == PROC_MGR_BOOTMODE_NOBOOT)
		proc_handle->state = PROC_MGR_STATE_RUNNNING;
	return retval;
}


/*
 * Function to detach from the Processor.
 *
 * This function calls into the specific Processor implementation
 * to detach from it.
 * This function is called from the ProcMgr detach function, and
 * hence is useful to perform any activities that may be required
 * before the slave is powered down.
 * Depending on the type of Processor, this function may or may not
 * perform any activities.
 */
inline int processor_detach(void *handle)
{
	int retval = 0;
	struct processor_object *proc_handle =
					(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	BUG_ON(proc_handle->proc_fxn_table.detach == NULL);

	retval = proc_handle->proc_fxn_table.detach(handle);
	/* For all boot modes, at the end of detach, the Processor is in
	* unknown state.
	*/
	proc_handle->state = PROC_MGR_STATE_UNKNOWN;
	return retval;
}


/*
 * Function to start the processor.
 *
 * This function calls into the specific Processor implementation
 * to start the slave processor running.
 * This function starts the slave processor running, in most
 * devices, by programming its entry point into the boot location
 * of the slave processor and releasing it from reset.
 * The handle specifies the specific Processor instance to be used.
 *
 *  @param  handle void * to the Processor object
 *  @param  entryPt	Entry point of the file loaded on the slave Processor
 *
 *  @sa	 Processor_stop
 */
inline int processor_start(void *handle, u32 entry_pt,
				struct processor_start_params *params)
{
	int retval = 0;
	struct processor_object *proc_handle =
					(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	/* entryPt may be 0 for some devices. Cannot check for valid/invalid. */
	BUG_ON(params == NULL);
	BUG_ON(proc_handle->proc_fxn_table.start == NULL);
	retval = proc_handle->proc_fxn_table.start(handle, entry_pt, params);

	if ((proc_handle->boot_mode == PROC_MGR_BOOTMODE_BOOT)
		|| (proc_handle->boot_mode == PROC_MGR_BOOTMODE_NOLOAD))
		proc_handle->state = PROC_MGR_STATE_RUNNNING;

	return retval;
}


/*
 * Function to stop the processor.
 *
 * This function calls into the specific Processor implementation
 * to stop the slave processor.
 * This function stops the slave processor running, in most
 * devices, by placing it in reset.
 * The handle specifies the specific Processor instance to be used.
 */
inline int processor_stop(void *handle,
				struct processor_stop_params *params)
{
	int retval = 0;
	struct processor_object *proc_handle =
					(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	BUG_ON(proc_handle->proc_fxn_table.stop == NULL);

	retval = proc_handle->proc_fxn_table.stop(handle, params);

	if ((proc_handle->boot_mode == PROC_MGR_BOOTMODE_BOOT)
	||  (proc_handle->boot_mode == PROC_MGR_BOOTMODE_NOLOAD))
		proc_handle->state = PROC_MGR_STATE_RESET;

	return retval;
}


/*
 * Function to read from the slave processor's memory.
 *
 * This function calls into the specific Processor implementation
 * to read from the slave processor's memory. It reads from the
 * specified address in the processor's address space and copies
 * the required number of bytes into the specified buffer.
 * It returns the number of bytes actually read in the num_bytes
 * parameter.
 * Depending on the processor implementation, it may result in
 * reading from shared memory or across a peripheral physical
 * connectivity.
 * The handle specifies the specific Processor instance to be used.
 */
inline int processor_read(void *handle, u32 proc_addr,
			u32 *num_bytes, void *buffer)
{
	int retval = 0;
	struct processor_object *proc_handle =
				(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	BUG_ON(proc_addr == 0);
	BUG_ON(num_bytes == 0);
	BUG_ON(buffer == NULL);
	BUG_ON(proc_handle->proc_fxn_table.read == NULL);

	retval = proc_handle->proc_fxn_table.read(handle, proc_addr,
						num_bytes, buffer);
	return retval;
}


/*
 * Function to write into the slave processor's memory.
 *
 * This function calls into the specific Processor implementation
 * to write into the slave processor's memory. It writes into the
 * specified address in the processor's address space and copies
 * the required number of bytes from the specified buffer.
 * It returns the number of bytes actually written in the num_bytes
 * parameter.
 * Depending on the processor implementation, it may result in
 * writing into shared memory or across a peripheral physical
 * connectivity.
 * The handle specifies the specific Processor instance to be used.
 */
inline int processor_write(void *handle, u32 proc_addr, u32 *num_bytes,
							void *buffer)
{
	int retval = 0;
	struct processor_object *proc_handle =
				(struct processor_object *)handle;
	BUG_ON(handle == NULL);
	BUG_ON(proc_addr == 0);
	BUG_ON(num_bytes == 0);
	BUG_ON(buffer == NULL);
	BUG_ON(proc_handle->proc_fxn_table.write == NULL);

	retval = proc_handle->proc_fxn_table.write(handle, proc_addr,
						num_bytes, buffer);
	return retval;
}


/*
 * Function to get the current state of the slave Processor.
 *
 * This function gets the state of the slave processor as
 * maintained on the master Processor state machine. It does not
 * go to the slave processor to get its actual state at the time
 * when this API is called.
 */
enum proc_mgr_state processor_get_state(void *handle)
{
	struct processor_object *proc_handle =
				(struct processor_object *)handle;

	BUG_ON(handle == NULL);

	return proc_handle->state;
}


/*
 * Function to set the current state of the slave Processor
 * to specified value.
 *
 * This function is used to set the state of the processor to the
 * value as specified. This function may be used by external
 * entities that affect the state of the slave processor, such as
 * PwrMgr, error handler, or ProcMgr.
 */
void processor_set_state(void *handle, enum proc_mgr_state state)
{
	struct processor_object *proc_handle =
				(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	proc_handle->state = state;
}


/*
 * Function to perform device-dependent operations.
 *
 * This function calls into the specific Processor implementation
 * to perform device dependent control operations. The control
 * operations supported by the device are exposed directly by the
 * specific implementation of the Processor interface. These
 * commands and their specific argument types are used with this
 * function.
 */
inline int processor_control(void *handle, int cmd, void *arg)
{
	int retval = 0;
	struct processor_object *proc_handle =
				(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	BUG_ON(proc_handle->proc_fxn_table.control == NULL);

	retval = proc_handle->proc_fxn_table.control(handle, cmd, arg);
	return retval;
}


/*
 * Function to translate between two types of address spaces.
 *
 * This function translates addresses between two types of address
 * spaces. The destination and source address types are indicated
 * through parameters specified in this function.
 */
inline int processor_translate_addr(void *handle, void **dst_addr,
		enum proc_mgr_addr_type dst_addr_type, void *src_addr,
		enum proc_mgr_addr_type src_addr_type)
{
	int retval = 0;
	struct processor_object *proc_handle =
					(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	BUG_ON(dst_addr == NULL);
	BUG_ON(src_addr == NULL);
	BUG_ON(dst_addr_type >= PROC_MGR_ADDRTYPE_ENDVALUE);
	BUG_ON(src_addr_type >= PROC_MGR_ADDRTYPE_ENDVALUE);
	BUG_ON(proc_handle->proc_fxn_table.translateAddr == NULL);

	retval = proc_handle->proc_fxn_table.translateAddr(handle,
			dst_addr, dst_addr_type, src_addr, src_addr_type);
	return retval;
}


/*
 * Function to map address to slave address space.
 *
 * This function maps the provided slave address to a host address
 * and returns the mapped address and size.
 */
inline int processor_map(void *handle, u32 proc_addr, u32 size,
			u32 *mapped_addr, u32 *mapped_size, u32 map_attribs)
{
	int retval = 0;
	struct processor_object *proc_handle =
				(struct processor_object *)handle;

	BUG_ON(handle == NULL);
	BUG_ON(proc_addr == 0);
	BUG_ON(size == 0);
	BUG_ON(mapped_addr == NULL);
	BUG_ON(mapped_size == NULL);
	BUG_ON(proc_handle->proc_fxn_table.map == NULL);

	retval = proc_handle->proc_fxn_table.map(handle, proc_addr,
			size, mapped_addr, mapped_size, map_attribs);
	return retval;
}

/*
 * Function to unmap address to slave address space.
 *
 * This function unmap the provided slave address
 */
inline int processor_unmap(void *handle, u32 mapped_addr)
{
	int retval = 0;
	struct processor_object *proc_handle =
				(struct processor_object *)handle;

	retval = proc_handle->proc_fxn_table.unmap(handle, mapped_addr);
	return retval;
}

/*
 * Function that registers for notification when the slave
 * processor transitions to any of the states specified.
 *
 * This function allows the user application to register for
 * changes in processor state and take actions accordingly.

 */
inline int processor_register_notify(void *handle, proc_mgr_callback_fxn fxn,
				void *args, enum proc_mgr_state state[])
{
	int retval = 0;

	BUG_ON(handle == NULL);
	BUG_ON(fxn == NULL);

	/* TODO: TBD: To be implemented. */
	return retval;
}

/*
 * Function that returns the proc instance mem info
 */
int processor_get_proc_info(void *handle, struct proc_mgr_proc_info *procinfo)
{
	struct processor_object *proc_handle =
				(struct processor_object *)handle;
	int retval;
	retval = proc_handle->proc_fxn_table.procinfo(proc_handle, procinfo);
	return retval;
}

/*
 * Function that returns the address translations
 */
int processor_virt_to_phys(void *handle, u32 da, u32 *mapped_entries,
						u32 num_of_entries)
{
	struct processor_object *proc_handle =
				(struct processor_object *)handle;
	int retval;
	retval = proc_handle->proc_fxn_table.virt_to_phys(handle, da,
				mapped_entries, num_of_entries);
	return retval;
}