struct mali_pmu_core *mali_pmu_create(_mali_osk_resource_t *resource)
{
struct mali_pmu_core* pmu;
MALI_DEBUG_ASSERT(NULL == mali_global_pmu_core);
MALI_DEBUG_PRINT(2, ("Mali PMU: Creating Mali PMU core\n"));
pmu = (struct mali_pmu_core *)_mali_osk_malloc(sizeof(struct mali_pmu_core));
if (NULL != pmu) {
pmu->lock = _mali_osk_spinlock_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_PMU);
if (NULL != pmu->lock) {
pmu->registered_cores_mask = mali_pmu_detect_mask();
pmu->active_cores_mask = pmu->registered_cores_mask;
if (_MALI_OSK_ERR_OK == mali_hw_core_create(&pmu->hw_core, resource, PMU_REGISTER_ADDRESS_SPACE_SIZE)) {
_mali_osk_errcode_t err;
struct _mali_osk_device_data data = { 0, };
err = _mali_osk_device_data_get(&data);
if (_MALI_OSK_ERR_OK == err) {
pmu->switch_delay = data.pmu_switch_delay;
mali_global_pmu_core = pmu;
return pmu;
}
mali_hw_core_delete(&pmu->hw_core);
}
_mali_osk_spinlock_term(pmu->lock);
}
_mali_osk_free(pmu);
}
return NULL;
}
struct mali_dma_core *mali_dma_create(_mali_osk_resource_t *resource)
{
struct mali_dma_core* dma;
_mali_osk_errcode_t err;
MALI_DEBUG_ASSERT(NULL == mali_global_dma_core);
dma = _mali_osk_malloc(sizeof(struct mali_dma_core));
if (dma == NULL) goto alloc_failed;
dma->lock = _mali_osk_spinlock_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_DMA_COMMAND);
if (NULL == dma->lock) goto lock_init_failed;
dma->pool = mali_dma_pool_create(MALI_DMA_CMD_BUF_SIZE, 4, 0);
if (NULL == dma->pool) goto dma_pool_failed;
err = mali_hw_core_create(&dma->hw_core, resource, MALI450_DMA_REG_SIZE);
if (_MALI_OSK_ERR_OK != err) goto hw_core_failed;
mali_global_dma_core = dma;
MALI_DEBUG_PRINT(2, ("Mali DMA: Created Mali APB DMA unit\n"));
return dma;
/* Error handling */
hw_core_failed:
mali_dma_pool_destroy(dma->pool);
dma_pool_failed:
_mali_osk_spinlock_term(dma->lock);
lock_init_failed:
_mali_osk_free(dma);
alloc_failed:
MALI_DEBUG_PRINT(2, ("Mali DMA: Failed to create APB DMA unit\n"));
return NULL;
}
void mali_pmu_delete(struct mali_pmu_core *pmu)
{
MALI_DEBUG_ASSERT_POINTER(pmu);
MALI_DEBUG_ASSERT(pmu == mali_global_pmu_core);
MALI_DEBUG_PRINT(2, ("Mali PMU: Deleting Mali PMU core\n"));
_mali_osk_spinlock_term(pmu->lock);
mali_hw_core_delete(&pmu->hw_core);
_mali_osk_free(pmu);
mali_global_pmu_core = NULL;
}
void mali_dma_delete(struct mali_dma_core *dma)
{
MALI_DEBUG_ASSERT_POINTER(dma);
MALI_DEBUG_PRINT(2, ("Mali DMA: Deleted Mali APB DMA unit\n"));
mali_hw_core_delete(&dma->hw_core);
_mali_osk_spinlock_term(dma->lock);
mali_dma_pool_destroy(dma->pool);
_mali_osk_free(dma);
}
void _mali_osk_bitmap_term(struct _mali_osk_bitmap *bitmap)
{
MALI_DEBUG_ASSERT_POINTER(bitmap);
if (NULL != bitmap->lock) {
_mali_osk_spinlock_term(bitmap->lock);
}
if (NULL != bitmap->table) {
kfree(bitmap->table);
}
}
void mali_gp_scheduler_terminate(void)
{
MALI_DEBUG_ASSERT(MALI_GP_SLOT_STATE_IDLE == slot.state
|| MALI_GP_SLOT_STATE_DISABLED == slot.state);
MALI_DEBUG_ASSERT_POINTER(slot.group);
mali_group_delete(slot.group);
_mali_osk_wait_queue_term(gp_scheduler_working_wait_queue);
#if defined(MALI_UPPER_HALF_SCHEDULING)
_mali_osk_spinlock_irq_term(gp_scheduler_lock);
#else
_mali_osk_spinlock_term(gp_scheduler_lock);
#endif /* defined(MALI_UPPER_HALF_SCHEDULING) */
}
int _mali_osk_bitmap_init(struct _mali_osk_bitmap *bitmap, u32 num, u32 reserve)
{
MALI_DEBUG_ASSERT_POINTER(bitmap);
MALI_DEBUG_ASSERT(reserve <= num);
bitmap->reserve = reserve;
bitmap->last = reserve;
bitmap->max = num;
bitmap->avail = num - reserve;
bitmap->lock = _mali_osk_spinlock_init(_MALI_OSK_LOCKFLAG_UNORDERED, _MALI_OSK_LOCK_ORDER_FIRST);
if (!bitmap->lock) {
return _MALI_OSK_ERR_NOMEM;
}
bitmap->table = kzalloc(BITS_TO_LONGS(bitmap->max) *
sizeof(long), GFP_KERNEL);
if (!bitmap->table) {
_mali_osk_spinlock_term(bitmap->lock);
return _MALI_OSK_ERR_NOMEM;
}
return _MALI_OSK_ERR_OK;
}
_mali_osk_errcode_t mali_gp_scheduler_initialize(void)
{
u32 num_groups;
u32 i;
_mali_osk_errcode_t ret = _MALI_OSK_ERR_OK;
#if defined(MALI_UPPER_HALF_SCHEDULING)
gp_scheduler_lock = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_SCHEDULER);
#else
gp_scheduler_lock = _mali_osk_spinlock_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_SCHEDULER);
#endif /* defined(MALI_UPPER_HALF_SCHEDULING) */
if (NULL == gp_scheduler_lock) {
ret = _MALI_OSK_ERR_NOMEM;
goto cleanup;
}
gp_scheduler_working_wait_queue = _mali_osk_wait_queue_init();
if (NULL == gp_scheduler_working_wait_queue) {
ret = _MALI_OSK_ERR_NOMEM;
goto cleanup;
}
/* Find all the available GP cores */
num_groups = mali_group_get_glob_num_groups();
for (i = 0; i < num_groups; i++) {
struct mali_group *group = mali_group_get_glob_group(i);
MALI_DEBUG_ASSERT(NULL != group);
if (NULL != group) {
struct mali_gp_core *gp_core = mali_group_get_gp_core(group);
if (NULL != gp_core) {
if (0 == gp_version) {
/* Retrieve GP version */
gp_version = mali_gp_core_get_version(gp_core);
}
slot.group = group;
slot.state = MALI_GP_SLOT_STATE_IDLE;
break; /* There is only one GP, no point in looking for more */
}
} else {
ret = _MALI_OSK_ERR_ITEM_NOT_FOUND;
goto cleanup;
}
}
return _MALI_OSK_ERR_OK;
cleanup:
if (NULL != gp_scheduler_working_wait_queue) {
_mali_osk_wait_queue_term(gp_scheduler_working_wait_queue);
gp_scheduler_working_wait_queue = NULL;
}
if (NULL != gp_scheduler_lock) {
#if defined(MALI_UPPER_HALF_SCHEDULING)
_mali_osk_spinlock_irq_term(gp_scheduler_lock);
#else
_mali_osk_spinlock_term(gp_scheduler_lock);
#endif /* defined(MALI_UPPER_HALF_SCHEDULING) */
gp_scheduler_lock = NULL;
}
return ret;
}
