← Back to branch summary

~thopiekar/arm-mali/mali-400-kernel-drivers-sunxi

« back to all changes in this revision

Viewing changes to driver/src/devicedrv/ump/common/ump_kernel_api.c

  • Committer: Dmitriy Beykun
  • Date: 2012-10-21 16:12:55 UTC
  • Revision ID: git-v1:23debc5a26ce858ef020405dbf91b2f268a72f44
added r3p0-04rel0 kernel drivers

Show diffs side-by-side

added added

removed removed

Lines of Context:
driver/src/devicedrv/ump/common/ump_kernel_api.c
144
144
 
145
145
        new_ref = _ump_osk_atomic_inc_and_read(&mem->ref_count);
146
146
 
147
 
        DBG_MSG(4, ("Memory reference incremented. ID: %u, new value: %d\n", mem->secure_id, new_ref));
 
147
        DBG_MSG(5, ("Memory reference incremented. ID: %u, new value: %d\n", mem->secure_id, new_ref));
148
148
}
149
149
 
150
150
 
164
164
 
165
165
        new_ref = _ump_osk_atomic_dec_and_read(&mem->ref_count);
166
166
 
167
 
        DBG_MSG(4, ("Memory reference decremented. ID: %u, new value: %d\n", mem->secure_id, new_ref));
 
167
        DBG_MSG(5, ("Memory reference decremented. ID: %u, new value: %d\n", mem->secure_id, new_ref));
168
168
 
169
169
        if (0 == new_ref)
170
170
        {
299
299
        void *virtual = NULL;
300
300
        u32 size = 0;
301
301
        u32 offset = 0;
 
302
 
302
303
        _mali_osk_lock_wait(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
303
304
        ump_descriptor_mapping_get(device.secure_id_map, (int)args->secure_id, (void**)&mem);
304
305
 
328
329
                DBG_MSG(3, ("_ump_ukk_msync IGNORING ID: %u Enabled: %d  OP: %d\n", (ump_secure_id)args->secure_id, mem->is_cached, args->op));
329
330
                goto msync_release_and_return;
330
331
        }
331
 
        DBG_MSG(3, ("_ump_ukk_msync FLUSHING ID: %u Enabled: %d  OP: %d Address: 0x%08x Mapping: 0x%08x\n",
332
 
                    (ump_secure_id)args->secure_id, mem->is_cached, args->op, args->address, args->mapping));
 
332
        DBG_MSG(3, ("UMP[%02u] _ump_ukk_msync  Flush  OP: %d Address: 0x%08x Mapping: 0x%08x\n",
 
333
                    (ump_secure_id)args->secure_id, args->op, args->address, args->mapping));
333
334
 
334
335
        if ( args->address )
335
336
        {
354
355
        }
355
356
 
356
357
        /* The actual cache flush - Implemented for each OS*/
357
 
        _ump_osk_msync( mem, virtual, offset, size, args->op);
 
358
        _ump_osk_msync( mem, virtual, offset, size, args->op, NULL);
358
359
 
359
360
msync_release_and_return:
360
361
        ump_dd_reference_release(mem);
361
362
        return;
362
363
}
 
364
 
 
365
void _ump_ukk_cache_operations_control(_ump_uk_cache_operations_control_s* args)
 
366
{
 
367
        ump_session_data * session_data;
 
368
        ump_uk_cache_op_control op;
 
369
 
 
370
        DEBUG_ASSERT_POINTER( args );
 
371
        DEBUG_ASSERT_POINTER( args->ctx );
 
372
 
 
373
        op = args->op;
 
374
        session_data = (ump_session_data *)args->ctx;
 
375
 
 
376
        _mali_osk_lock_wait(session_data->lock, _MALI_OSK_LOCKMODE_RW);
 
377
        if ( op== _UMP_UK_CACHE_OP_START )
 
378
        {
 
379
                session_data->cache_operations_ongoing++;
 
380
                DBG_MSG(4, ("Cache ops start\n" ));
 
381
                if ( session_data->cache_operations_ongoing != 1 )
 
382
                {
 
383
                        DBG_MSG(2, ("UMP: Number of simultanious cache control ops: %d\n", session_data->cache_operations_ongoing) );
 
384
                }
 
385
        }
 
386
        else if ( op== _UMP_UK_CACHE_OP_FINISH )
 
387
        {
 
388
                DBG_MSG(4, ("Cache ops finish\n"));
 
389
                session_data->cache_operations_ongoing--;
 
390
                #if 0
 
391
                if ( session_data->has_pending_level1_cache_flush)
 
392
                {
 
393
                        /* This function will set has_pending_level1_cache_flush=0 */
 
394
                        _ump_osk_msync( NULL, NULL, 0, 0, _UMP_UK_MSYNC_FLUSH_L1, session_data);
 
395
                }
 
396
                #endif
 
397
 
 
398
                /* to be on the safe side: always flush l1 cache when cache operations are done */
 
399
                _ump_osk_msync( NULL, NULL, 0, 0, _UMP_UK_MSYNC_FLUSH_L1, session_data);
 
400
                DBG_MSG(4, ("Cache ops finish end\n" ));
 
401
        }
 
402
        else
 
403
        {
 
404
                DBG_MSG(1, ("Illegal call to %s at line %d\n", __FUNCTION__, __LINE__));
 
405
        }
 
406
        _mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
 
407
 
 
408
}
 
409
 
 
410
void _ump_ukk_switch_hw_usage(_ump_uk_switch_hw_usage_s *args )
 
411
{
 
412
        ump_dd_mem * mem = NULL;
 
413
        ump_uk_user old_user;
 
414
        ump_uk_msync_op cache_op = _UMP_UK_MSYNC_CLEAN_AND_INVALIDATE;
 
415
        ump_session_data *session_data;
 
416
 
 
417
        DEBUG_ASSERT_POINTER( args );
 
418
        DEBUG_ASSERT_POINTER( args->ctx );
 
419
 
 
420
        session_data = (ump_session_data *)args->ctx;
 
421
 
 
422
        _mali_osk_lock_wait(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
423
        ump_descriptor_mapping_get(device.secure_id_map, (int)args->secure_id, (void**)&mem);
 
424
 
 
425
        if (NULL == mem)
 
426
        {
 
427
                _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
428
                DBG_MSG(1, ("Failed to look up mapping in _ump_ukk_switch_hw_usage(). ID: %u\n", (ump_secure_id)args->secure_id));
 
429
                return;
 
430
        }
 
431
 
 
432
        old_user = mem->hw_device;
 
433
        mem->hw_device = args->new_user;
 
434
 
 
435
        DBG_MSG(3, ("UMP[%02u] Switch usage  Start  New: %s  Prev: %s.\n", (ump_secure_id)args->secure_id, args->new_user?"MALI":"CPU",old_user?"MALI":"CPU"));
 
436
 
 
437
        if ( ! mem->is_cached )
 
438
        {
 
439
                _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
440
                DBG_MSG(3, ("UMP[%02u] Changing owner of uncached memory. Cache flushing not needed.\n", (ump_secure_id)args->secure_id));
 
441
                return;
 
442
        }
 
443
 
 
444
        if ( old_user == args->new_user)
 
445
        {
 
446
                _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
447
                DBG_MSG(4, ("UMP[%02u] Setting the new_user equal to previous for. Cache flushing not needed.\n", (ump_secure_id)args->secure_id));
 
448
                return;
 
449
        }
 
450
        if (
 
451
                 /* Previous AND new is both different from CPU */
 
452
                 (old_user != _UMP_UK_USED_BY_CPU) && (args->new_user != _UMP_UK_USED_BY_CPU  )
 
453
           )
 
454
        {
 
455
                _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
456
                DBG_MSG(4, ("UMP[%02u] Previous and new user is not CPU. Cache flushing not needed.\n", (ump_secure_id)args->secure_id));
 
457
                return;
 
458
        }
 
459
 
 
460
        if ( (old_user != _UMP_UK_USED_BY_CPU ) && (args->new_user==_UMP_UK_USED_BY_CPU) )
 
461
        {
 
462
                cache_op =_UMP_UK_MSYNC_INVALIDATE;
 
463
                DBG_MSG(4, ("UMP[%02u] Cache invalidation needed\n", (ump_secure_id)args->secure_id));
 
464
#ifdef UMP_SKIP_INVALIDATION
 
465
#error
 
466
                _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
467
                DBG_MSG(4, ("UMP[%02u] Performing Cache invalidation SKIPPED\n", (ump_secure_id)args->secure_id));
 
468
                return;
 
469
#endif
 
470
        }
 
471
        /* Ensure the memory doesn't dissapear when we are flushing it. */
 
472
        ump_dd_reference_add(mem);
 
473
        _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
474
 
 
475
        /* Take lock to protect: session->cache_operations_ongoing and session->has_pending_level1_cache_flush */
 
476
        _mali_osk_lock_wait(session_data->lock, _MALI_OSK_LOCKMODE_RW);
 
477
        /* Actual cache flush */
 
478
        _ump_osk_msync( mem, NULL, 0, mem->size_bytes, cache_op, session_data);
 
479
        _mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
 
480
 
 
481
        ump_dd_reference_release(mem);
 
482
        DBG_MSG(4, ("UMP[%02u] Switch usage  Finish\n", (ump_secure_id)args->secure_id));
 
483
        return;
 
484
}
 
485
 
 
486
void _ump_ukk_lock(_ump_uk_lock_s *args )
 
487
{
 
488
        ump_dd_mem * mem = NULL;
 
489
 
 
490
        _mali_osk_lock_wait(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
491
        ump_descriptor_mapping_get(device.secure_id_map, (int)args->secure_id, (void**)&mem);
 
492
 
 
493
        if (NULL == mem)
 
494
        {
 
495
                _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
496
                DBG_MSG(1, ("UMP[%02u] Failed to look up mapping in _ump_ukk_lock(). ID: %u\n", (ump_secure_id)args->secure_id));
 
497
                return;
 
498
        }
 
499
        ump_dd_reference_add(mem);
 
500
        _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
501
 
 
502
        DBG_MSG(1, ("UMP[%02u] Lock. New lock flag: %d. Old Lock flag:\n", (u32)args->secure_id, (u32)args->lock_usage, (u32) mem->lock_usage ));
 
503
 
 
504
        mem->lock_usage = (ump_lock_usage) args->lock_usage;
 
505
 
 
506
        /** TODO: TAKE LOCK HERE */
 
507
 
 
508
        ump_dd_reference_release(mem);
 
509
}
 
510
 
 
511
void _ump_ukk_unlock(_ump_uk_unlock_s *args )
 
512
{
 
513
        ump_dd_mem * mem = NULL;
 
514
 
 
515
        _mali_osk_lock_wait(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
516
        ump_descriptor_mapping_get(device.secure_id_map, (int)args->secure_id, (void**)&mem);
 
517
 
 
518
        if (NULL == mem)
 
519
        {
 
520
                _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
521
                DBG_MSG(1, ("Failed to look up mapping in _ump_ukk_unlock(). ID: %u\n", (ump_secure_id)args->secure_id));
 
522
                return;
 
523
        }
 
524
        ump_dd_reference_add(mem);
 
525
        _mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
 
526
 
 
527
        DBG_MSG(1, ("UMP[%02u] Unlocking. Old Lock flag:\n", (u32)args->secure_id, (u32) mem->lock_usage ));
 
528
 
 
529
        mem->lock_usage = (ump_lock_usage) UMP_NOT_LOCKED;
 
530
 
 
531
        /** TODO: RELEASE LOCK HERE */
 
532
 
 
533
        ump_dd_reference_release(mem);
 
534
}