void kfree(void* address)
{
kdebug("< kfree %d", address);
// start of block
malloc_block_t* block = address - (uint32_t)&(((malloc_block_t*)0)->data);
check_block(block);
int size = block->size;
int flags = block->flags & ~MALLOC_USED;
// if next block is free, merge with it
if ((block->flags&MALLOC_LAST)==0) {
malloc_block_t* next = BLOCK_NEXT(block);
if ((next->flags&MALLOC_USED)==0) {
size += next->size;
flags |= (next->flags&MALLOC_LAST);
}
}
// if previous block is free, merge with it
if ((block->flags&MALLOC_FIRST)==0) {
malloc_block_t* prev = BLOCK_PREVIOUS(block);
if ((prev->flags&MALLOC_USED)==0) {
size += prev->size;
flags |= (prev->flags&MALLOC_FIRST);
block = prev;
}
}
setup_block(block, flags, size);
kmalloc_print();
kdebug(">");
}
int Syscall::kcall_threadresume(CoreData& core_data, Thread *currt) {
/*
* Resume a thread that has been stopped
*
* KPARM1 : pid
* KPARM2 : tid
*
* KRETVAL : 0 or -ERRNO
*/
Thread *resumer;
kdebug("kcall_threadresume\n");
if ((resumer = get_thread_ref(KPARM1, KPARM2)) == NULL) {
kdebug("kcall_threadresume ESRCH %d err %d\n", KPARM2, ESRCH);
return -ESRCH;
}
sys.m_sched.add(resumer, 1);
resumer->unref();
return 0;
}
int mm_info(mm_context *ctx, void *addr, anvil_vmm_info_t& info)
{
struct mm_mapping *pmap;
kdebug("mm_info\n");
mm_context_dump(ctx);
// Iterate thru till we find the first mapping whose start is >= addr
rwlock_wrlock(&ctx->lock);
pmap = first_mapping(ctx);
while (pmap)
{
uintptr_t pmap_end = pmap->start_addr + pmap->length;
if ((uintptr_t)addr <= pmap->start_addr)
{
info.addr = (void *)pmap->start_addr;
info.object = pmap->object;
info.len = pmap->length;
info.fd = pmap->fd;
info.prot = pmap->prot;
kdebug("mm_info found\n");
rwlock_unlock(&ctx->lock);
return 0;
}
pmap = next_mapping(ctx, pmap);
}
rwlock_unlock(&ctx->lock);
kdebug("mm_info done\n");
return -1;
}
////////////////////////////////////////////////////
// 功能: 等待DMA结束
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
static void DacWaiteDmaEnd()
{
int i,time;
PRESAMPLE presample;
if( ListEmpty(&DacList) )
return;
kdebug(mod_audio, PRINT_INFO, "DacWaiteDmaEnd start\n");
presample = &DacDevice;
time = 0;
while(1)
{
for( i = 0 ; i < MAX_PCMBUFS ; i++ )
{
if( presample->BufFlag[i] != DAC_BUF_WRITE )
break;
}
if( i == MAX_PCMBUFS )
break;
sTimerSleep(10,NULL);
time++;
if( time > 40 )
break;
if( GetDacChannel() != 1 )
break;
}
kdebug(mod_audio, PRINT_INFO, "DacWaiteDmaEnd end\n");
return;
}
////////////////////////////////////////////////////
// 功能: 打开codec设备
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
void OpenMediaCodecDevice()
{
unsigned char pmr1;
pmr1 = codec_reg_read(A_CODEC_PMR1);
kdebug(mod_media, PRINT_INFO, "pmr1 = %x\n",pmr1);
#ifdef CODEC_ALWAYS_OPEN
if( codec_reg_read(A_CODEC_PMR1) & 0x90)
{ //CODEC处于开的状态，不需要重新打开
if( fDeviceStatus == DEVICE_OPEN_STATUS )
{
fDeviceStatus = DEVICE_OPEN_STATUS;
kdebug(mod_media, PRINT_INFO, "codec is already open\n");
return;
}
goto OPEN_MEDIA_CODEC_DEVICE;
}
else //CODEC处于关闭状态，必须重新打开CODEC
{
kdebug(mod_media, PRINT_ERROR, "codec is close, need to open codec\n");
goto OPEN_MEDIA_CODEC_DEVICE;
}
#endif
if( fDeviceStatus == DEVICE_OPEN_STATUS )
{
kdebug(mod_media, PRINT_INFO, "codec is already open\n");
return;
}
#ifdef CODEC_ALWAYS_OPEN
OPEN_MEDIA_CODEC_DEVICE:
SetMoseCe(1);//0 //修改复位开机声音小的问题。
#endif
kdebug(mod_media, PRINT_INFO, "open media device\n");
fDeviceStatus = DEVICE_OPEN_STATUS;
//codec寄存器设置
codec_reg_write(A_CODEC_AICR, 0x0F);
codec_reg_write(A_CODEC_TR1,0x00); // 0x02);
codec_reg_write(A_CODEC_IFR, 0xFF); //Write 1 to Update of the flag
codec_reg_write(A_CODEC_ICR, 0x3F);
codec_reg_write(A_CODEC_CR2, 0x60);
codec_reg_write(A_CODEC_CR3, 0xC0); //??
codec_reg_write(A_CODEC_CGR8, 0x1f); //??
codec_reg_write(A_CODEC_CGR9, 0x1f); //??
codec_reg_write(A_CODEC_CGR1, 0xff);
codec_reg_write(A_CODEC_CGR10, 0);
codec_reg_clear(A_CODEC_PMR2, SB);
MillinsecoundDelay(10);
codec_reg_clear(A_CODEC_PMR2, SB_SLEEP);
codec_reg_clear(A_CODEC_PMR1, SB_DAC);
codec_reg_clear(A_CODEC_PMR1, SB_ADC);
codec_reg_clear(A_CODEC_PMR2, SB_MC);
codec_reg_clear(A_CODEC_PMR1, SB_MIX);
codec_reg_clear(A_CODEC_PMR1, SB_OUT);
MillinsecoundDelay(20);
// 关闭音量开关
codec_reg_set(A_CODEC_CR1, DAC_MUTE);
}
void kmalloc_init(void* base, size_t size)
{
kdebug("< kmalloc_init %d, %d", base, size);
first_block = (malloc_block_t*)base;
setup_block(first_block, MALLOC_FIRST|MALLOC_LAST, size);
kmalloc_print();
kdebug(">");
}
bool KAccel::setKeyDict( QDict<KKeyEntry> nKeyDict )
{
kdebug(KDEBUG_INFO, 125, "Disconenct and remove");
// Disconnect and remove all items in pAccel
QDictIterator<KKeyEntry> *aKeyIt = new QDictIterator<KKeyEntry>( aKeyDict );
aKeyIt->toFirst();
#define pE aKeyIt->current()
while( pE ) {
QString s;
if ( pE->aAccelId && pE->aCurrentKeyCode ) {
pAccel->disconnectItem( pE->aAccelId, pE->receiver,
pE->member );
pAccel->removeItem( pE->aAccelId );
}
++*aKeyIt;
}
#undef pE
kdebug(KDEBUG_INFO, 125, "Clear the dictionary");
// Clear the dictionary
aKeyDict.clear();
kdebug(KDEBUG_INFO, 125, "Insert new items");
// Insert the new items into the dictionary and reconnect if neccessary
// Note also swap config and current key codes !!!!!!
delete aKeyIt; // tanghus
aKeyIt = new QDictIterator<KKeyEntry>( nKeyDict );
aKeyIt->toFirst();
#define pE aKeyIt->current()
KKeyEntry *pEntry;
while( pE ) {
pEntry = new KKeyEntry;
aKeyDict.insert( aKeyIt->currentKey(), pEntry );
pEntry->aDefaultKeyCode = pE->aDefaultKeyCode;
// Note we write config key code to current key code !!
pEntry->aCurrentKeyCode = pE->aConfigKeyCode;
pEntry->aConfigKeyCode = pE->aConfigKeyCode;
pEntry->bConfigurable = pE->bConfigurable;
pEntry->aAccelId = pE->aAccelId;
pEntry->receiver = pE->receiver;
pEntry->member = pE->member;
pEntry->descr = pE->descr; // tanghus
if ( pEntry->aAccelId && pEntry->aCurrentKeyCode ) {
pAccel->insertItem( pEntry->aCurrentKeyCode, pEntry->aAccelId );
pAccel->connectItem( pEntry->aAccelId, pEntry->receiver,
pEntry->member);
}
++*aKeyIt;
}
#undef pE
delete aKeyIt; // tanghus
return true;
}
int MediaSrvDestroy(HANDLE hmedia)
#endif
{
PMEDIA_OBJECT obj;
int playback;
kMutexWait(hMediaMutex);
// 获取音频对象
obj = (PMEDIA_OBJECT)HandleGet(hmedia, MEDIA_MAGIC);
if(obj == NULL)
{
kdebug(mod_media, PRINT_ERROR, "CLOSE NULL: 0x%x\n", hmedia);
kMutexRelease(hMediaMutex);
return -1;
}
kdebug(mod_media, PRINT_INFO, "CLOSE: 0x%x\n", hmedia);
// 结束当前正在录放的音频任务
playback = obj->Cb.MediaClose(obj->Media, 1);
obj = (PMEDIA_OBJECT)HandleGet(hmedia, MEDIA_MAGIC);
if(obj == NULL)
{
kdebug(mod_media, PRINT_ERROR, "CLOSE NULL NULL: 0x%x\n", hmedia);
kMutexRelease(hMediaMutex);
return -1;
}
obj->Cb.MediaDestroy(obj->Media);
// 释放当前节点
ListRemove(&obj->Link);
HandleDestroy(hmedia, MEDIA_MAGIC);
if(obj->MediaInfo)
kfree(obj->MediaInfo);
kfree(obj);
// 启动下一个等待任务
if(!ListEmpty(&MediaObjList))
{
obj = ListEntry(ListFirst(&MediaObjList), MEDIA_OBJECT, Link);
if(playback && (obj->Mode == MEDIA_MODE_WAIT))
{
if(obj->Cb.MediaOpen(obj->Media) < 0)
{
HandleDestroy(obj->Header.Handle, MEDIA_MAGIC);
if(obj->MediaInfo)
kfree(obj->MediaInfo);
kfree(obj);
}
}
}
kMutexRelease(hMediaMutex);
return 0;
}
////////////////////////////////////////////////////
// 功能: 为音频任务申请并初始化节点
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
static PMEDIA_OBJECT MediaSrvObjCreate(void *media, char *name, int type)
{
PMEDIA_OBJECT obj;
// 输入参数检查
if(!media)
return NULL;
// 申请节点，并初始化
obj = kmalloc(sizeof(MEDIA_OBJECT));
if(obj == NULL)
return NULL;
kmemset(obj, 0x00, sizeof(MEDIA_OBJECT));
ListInit(&obj->Link);
if(MediaSrvGetCallback(type, &obj->Cb) < 0)
{
kdebug(mod_media, PRINT_ERROR, "MediaSrvGetCallback error\n");
kfree(obj);
return NULL;
}
if(((PMEDIA_TASK)media)->ExterdType == 1 && JzSrvUseMplayer() < 0)
{
kdebug(mod_media, PRINT_ERROR, "MediaSrvGetCallback error: mplayer already exist\n");
kfree(obj);
return NULL;
}
// 创建媒体任务
obj->Media = obj->Cb.MediaCreate(media);
if(obj->Media == NULL)
{
kfree(obj);
return NULL;
}
// 保存媒体名称
if(name)
{
obj->MediaInfo = kmalloc(kstrlen(name)+1);
if(obj->MediaInfo)
kstrcpy(obj->MediaInfo, name);
}
// 设置媒体任务
#if defined(STC_EXP)
obj->hTask = sTaskSelf();
#else
obj->hTask = TaskSelf();
#endif
// 返回媒体对象
return obj;
}
void acpi_print_hdr(uint32_t pphdr) {
#ifdef DEBUG
struct acpi_tbl_hdr *phdr = (struct acpi_tbl_hdr *)(uintptr_t)pphdr;
#endif
kdebug("sig='%.4s' len=%d rev=%d chk=%02x ",
phdr->sig, phdr->length, phdr->rev, phdr->chksum);
kdebug("%.6s %.8s %d %d %d \n",
phdr->oem_id, phdr->oem_tbl_id,
phdr->oem_rev, phdr->creator_id, phdr->creator_rev);
kdebug("\n");
}
int Thread::try_join(Thread* joiner, void **value_ptr)
{
/*
* We lock here because the joinable member might be cleared by the
* detach code
*/
rwlock_wrlock(&m_join_lock);
if (!m_joinable || m_joiner != NULL)
{
// Someone is already joining us so fail
rwlock_unlock(&m_join_lock);
kdebug("kcall_threadjoin not joinable or already joined\n");
return EINVAL;
}
if (m_state == THR_ST_ZOMBIE)
{
// We are a zombie, ready to be reaped
void *value = zombie_state_info.exit_val;
int err;
if (value_ptr && (err = joiner->kcopy_touser(value_ptr, &value, sizeof(value))) < 0)
{
return err;
}
rwlock_unlock(&m_join_lock);
die();
kdebug("kcall_threadjoin returning value\n");
return 0;
}
// We are not ready to be joined yet so block the joiner and queue him
// on our m_joiner member
//
// NOTE: Normally we don't allow threads to block other threads but this
// is a helper method executing because of a call from joiner
m_joiner = joiner;
joiner->joining_state_info.joined_to = this;
joiner->joining_state_info.value_ptr = value_ptr;
joiner->m_continuation_func = &Thread::join_cont;
// This blocks the tread that called this method i.e. joiner
sys.m_sched.block(THR_ST_JOINING);
//rwlock_unlock(&exiter->m_join_lock);
rwlock_unlock(&m_join_lock);
return 0;
}
////////////////////////////////////////////////////
// 功能:
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
int JzCtlSeek(PAK_OBJECT obj, DWORD milliSecond)
{
MEDIALIB_STATUS player_status;
// 检查是否为录音状态
if(obj->Task.Record)
return -1;
// 检查是否允许seek动作
if(!obj->Info.bAllowSeek)
{
kdebug(mod_media, PRINT_ERROR, "the media unsupport seeking!\n");
return -1;
}
// 暂停播放
player_status = MediaLibGetStatus(obj);
if(player_status == MEDIALIB_SEEK)
return 0;
if((player_status == MEDIALIB_PLAYING) || (player_status == MEDIALIB_PAUSE))
{
MediaLibSeek(obj, milliSecond);
}
return 0;
}
static void mm_commit_phys(mm_context *ctx, struct mm_mapping *mm, uint64_t physaddr)
{
uint64_t p;
uintptr_t start, end;
int writable;
start = mm->start_addr;
end = start + mm->length - 1;
start &= ~0xfff;
end = __PAGEROUND(end);
writable = mm->prot & PM_WRITABLE ? PM_WRITABLE : 0;
/* No backing required because we're mapping all pages now */
//mm->object->backing = none;
for (p=start; p<end; p+=__PAGESIZE)
{
struct phys_page *pagestruct;
uint64_t phys = physaddr;
physaddr += __PAGESIZE;
//kdebug("Mapping %016lx to %016lx\n", phys, p);
pagestruct = phys_to_pagestruct(phys);
pagestruct->offset = p - start;
mm->object->page_list.add_tail(pagestruct);
++mm->object->npages;
}
kdebug("******** mm_commit_phys done ********\n");
}
void displayInfo() {
Switch_t *swtch;
unsigned int i, count, lines;
SENSORS_PER_LINE = RIGHT_HALF / 10;
lines = SENSORS_PER_LINE;
lines = (TRAIN_SWITCH_COUNT / lines) + (TRAIN_SWITCH_COUNT % lines);
count = TRAIN_SWITCH_COUNT;
kdebug("Debugging Enabled...\r\nNumber of Debug Lines: %d", lines);
kprintf("====Switches===" MOVE_TO_COL CHANGE_COLOR "Train Calibration:" CHANGE_COLOR "\r\n" MOVE_TO_COL
"| Train | Velocity | Landmark | Distance (mm) | Next Landmark | ETA (ticks) | ATA (ticks) | Resv | "
MOVE_TO_COL, RIGHT_HALF + 5, YELLOW, 0, RIGHT_HALF + 5, 0);
while (count > 0) {
for (i = 0; i < MIN(count, SENSORS_PER_LINE); ++i) {
if (count <= 4) {
swtch = getSwitch(MULTI_SWITCH_OFFSET + (TRAIN_SWITCH_COUNT - count + i + 1));
} else {
swtch = getSwitch(TRAIN_SWITCH_COUNT - count + i + 1);
if (swtch->id < 10) {
kputstr("00");
} else if (swtch->id < 100) {
kputstr("0");
}
}
kprintf("%d: %c ", swtch->id, SWITCH_CHAR(swtch->state));
}
count -= MIN(SENSORS_PER_LINE, count);
kputstr(NEW_LINE);
}
kputstr("\r\n====Sensors====\r\n\r\n\r\n");
kprintf(SAVE_CURSOR SET_SCROLL RESTORE_CURSOR, TERM_OFFSET + lines + 4, TERMINAL_HEIGHT);
TERM_BOTTOM = TERM_OFFSET + lines + 4;
}
////////////////////////////////////////////////////
// 功能: 把DMA中的数据送入I2S
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
static void StartDmaPcmTrans(int mute, unsigned int sour)
{
PRESAMPLE pResample;
static DWORD mute_data;
pResample = &DacDevice;
//判断是否能传递数据
if(!mute)
{
//传送PCM数据
DmaDataToAic(0,(unsigned int)sour, DAC_PCMBUF_SIZE,1);
nMplayerDmaStart = 1;
#ifdef DAC_SAVE_PCM
kmemcpy(&dac_buf[dac_offset],(BYTE*)sour,DAC_PCMBUF_SIZE);
dac_offset += DAC_PCMBUF_SIZE;
if( dac_offset >= 4 * 1024 * 1024 )
dac_offset = 0;
#endif
mute_data = 0;
} else
{
//传送空的数据
DmaDataToAic(0, (unsigned int)NullBuf, DAC_PCMBUF_SIZE,1);
nMplayerDmaStart = 0;
#ifdef DAC_SAVE_PCM
kmemcpy(&dac_buf[dac_offset],(BYTE*)NullBuf,DAC_PCMBUF_SIZE);
dac_offset += DAC_PCMBUF_SIZE;
if( dac_offset >= 4 * 1024 * 1024 )
dac_offset = 0;
#endif
if( !fPause )
kdebug(mod_audio, PRINT_INFO, "MUTE: %d-%d\n", ++mute_data, fBeginDma);
}
}
////////////////////////////////////////////////////
// 功能: 关闭声音设备
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
void CloseMediaDevice(char channel)
{
int arg;
int time;
arg = ((channel == 0) ? RECORD_CHANNEL : PLAYBACK_CHANNEL );
//等待DMA结束
time = 0;
while( INREG32(A_DMA_DTC(arg)) )
{
#ifdef KPRINTF_DEF
kprintf("close media device : count = %x\n",INREG32(A_DMA_DTC(arg)));
#endif
sTimerSleep(10, NULL);
//加入延迟处理，防止死锁
time++;
if( time > 10 )
{
kdebug(mod_media, PRINT_WARNING, "close media device timer out\n");
break;
}
}
//stop dma
CLRREG32(A_DMA_DCS(arg), DCS_AR | DCS_HLT | DCS_CTE | DCS_CT);
//close aic
CLRREG32(AIC_CR, AIC_CR_ERPL);
SETREG32(AIC_CR, AIC_CR_FLUSH_FIFO);
OUTREG32(AIC_SR, 0x00000000);
#ifndef CODEC_ALWAYS_OPEN
CloseMediaCodecDevice();
#endif
}
int Thread::do_detach(int tid)
{
Thread *target;
kdebug("kcall_threadjoin %d %d\n", get_id(), tid);
if ((target = get_proc()->thread_getref_inactive(tid)) == NULL)
{
kdebug("kcall_threadjoin ESRCH %d err %d\n", tid, ESRCH);
return -ESRCH;
}
int err = target->try_detach();
target->unref();
return -err;
}
static struct acpi_rsdp *get_apci_ptr() {
uintptr_t ebda_address;
char *psig;
int i;
/*
* There are 2 places we could find the ACPI Root System Description
* Pointer.
* We need to validate the addresses we get, because they are untrusted
*/
/* a. In the first kilobyte of Extended BIOS Data Area (EBDA) */
ebda_address = *(uint16_t *)(0x40e);
ebda_address <<= 4;
kdebug("Ebda addr=%08x\n", ebda_address);
psig = (char *)(ebda_address);
if (psig) {
for (i=0; i<256; ++i) {
if (! strncmp(psig, RSD_PTR_SIG, strlen(RSD_PTR_SIG))) {
//kdebug("Found acpi ptr struct in first k of EBDA %d\n", i);
return (struct acpi_rsdp *)(psig);
}
psig += 16;
}
}
/* d. In the BIOS read-only memory space between 0E0000h and 0FFFFFh. */
psig = (char *)(0xe0000);
if (psig) {
for (i=0; i<32768; ++i) {
if (!strncmp(psig, RSD_PTR_SIG, strlen(RSD_PTR_SIG))) {
kdebug("Found acpi ptr struct in Bios ROM %d\n", i);
return (struct acpi_rsdp *)(psig);
}
psig += 16;
}
}
kprintf("Couldn't find acpi ptr struct\n");
return (struct acpi_rsdp *)NULL;
}
/*
* Schedule a garbage collection run.
* - time precision isn't particularly important
*/
void key_schedule_gc(time_t gc_at)
{
unsigned long expires;
time_t now = current_kernel_time().tv_sec;
kenter("%ld", gc_at - now);
if (gc_at <= now || test_bit(KEY_GC_REAP_KEYTYPE, &key_gc_flags)) {
kdebug("IMMEDIATE");
schedule_work(&key_gc_work);
} else if (gc_at < key_gc_next_run) {
kdebug("DEFERRED");
key_gc_next_run = gc_at;
expires = jiffies + (gc_at - now) * HZ;
mod_timer(&key_gc_timer, expires);
}
}
int addInterruptListener(int eventType, Task_t *t, void *buf, int buflen) {
/*
* Adds a task to the bucket awaiting a particular event.
* Returns 0 on success, -1 on event not existing, -2 on no space
*/
AwaitTask_t *taskEntry = NULL;
if (eventType >= NUM_INTERRUPTS) {
kdebug("Interrupt: Error: Invalid interrupt %d given.", eventType);
return -1;
}
taskEntry = &interruptTable[eventType];
if (taskEntry->blockedTask) {
kdebug("Interrupt: Error: Task already waiting (tid=%d).", taskEntry->blockedTask->tid);
return -2;
}
// something waiting on XMT, so enable those interrupts
switch (eventType) {
case UART1_RCV_INTERRUPT:
*u1ctlr |= RIEN_MASK;
break;
case UART1_XMT_INTERRUPT:
*u1ctlr |= TIEN_MASK;
break;
case UART1_MOD_INTERRUPT:
*u1ctlr |= MSIEN_MASK;
break;
case UART2_RCV_INTERRUPT:
*u2ctlr |= RIEN_MASK | RTIEN_MASK;
break;
case UART2_XMT_INTERRUPT:
*u2ctlr |= TIEN_MASK;
break;
}
taskEntry->blockedTask = t;
taskEntry->buf = buf;
taskEntry->buflen = buflen;
return 0;
}
int Thread::do_exit_thread(void *value)
{
/*
* Now we lock so others can't change our joiner member. Note that not
* only do joiners join us but the timer subsystem may timeout a joiner
* and remove him.
*/
deactivate();
rwlock_wrlock(&m_join_lock);
if (!m_joinable)
{
/* We cannot be joined so we die immediately */
kdebug("Thread::do_exit_thread() not joinable\n");
sys.m_sched.block(THR_ST_DEAD);
rwlock_unlock(&m_join_lock);
die();
return 0;
}
if (m_joiner != NULL)
{
/*
* Someone is waiting for us so make him ready. We don't need to
* lock him. The lock on us prevents anyone from touching the joiner
*/
kdebug("Thread::do_exit_thread() have joiner\n");
m_joiner->joining_state_info.value = value;
m_joiner->m_continuation_func = &Thread::join_cont;
sys.m_sched.add(m_joiner, 0);
sys.m_sched.block(THR_ST_DEAD);
rwlock_unlock(&m_join_lock);
die();
return 0;
}
kdebug("Thread::do_exit_thread() becoming zombie\n");
zombie_state_info.exit_val = value;
sys.m_sched.block(THR_ST_ZOMBIE);
rwlock_unlock(&m_join_lock);
return 0;
}
void* kmalloc(size_t payload)
{
malloc_block_t* block;
malloc_block_t* ptr;
kdebug("< kmalloc %d", payload);
block = 0;
ptr = first_block;
while (1) {
check_block(ptr);
// free and big enough ?
if (((ptr->flags&MALLOC_USED)==0) && (PAYLOAD_SIZE(ptr)>=payload)) {
// better than the current fit (if any) ?
if ((block==0) || (ptr->size<block->size)) {
block = ptr;
}
}
if (ptr->flags&MALLOC_LAST) {
break;
}
ptr = BLOCK_NEXT(ptr);
}
if (ptr==0) {
kpanic("could not allocate %d", payload);
return 0;
}
int split_block = (block->size > (payload+BLOCK_OVERHEAD));
if (split_block) {
int last = block->flags&MALLOC_LAST;
size_t size = payload + BLOCK_OVERHEAD;
size_t rem_size = block->size - size;
setup_block(block, (block->flags&~MALLOC_LAST)|MALLOC_USED, size);
setup_block(BLOCK_NEXT(block), last, rem_size);
} else {
block->flags |= MALLOC_USED;
}
kmalloc_print();
kdebug(">");
return (void*)block->data;
}
// set the int 0 timer to trigger a bit more than every ~53ms
void setup_timer() {
// 1.193182 MHz input clock
// divide by 1193 (0x04a9) to get around 1000Hz (~1000.15256 Hz)
kdebug("setting int0 timer ");
pic_mask_interrupt(INT_TIMER);
outb(0x43, 0x34); // 00110100b - chan 0, freq. divider, set lo/hi byte
outb(0x40, 0xa9); // Low byte of divider to chan 0 reload value
outb(0x40, 0x04); // High byte of divider to chan 0 reload value
kdebug("initialising ktimers");
/* Say we call it every 1000 useconds, when we really do every 999.847 useconds) */
ktimer_init(1000);
add_handler(INTR_BASE + INT_TIMER, &early_timer_isr);
pic_unmask_interrupt(INT_TIMER);
}
void ktrap_init() {
kdebug("ktrap_init()\n");
CP15VectorBaseAddrSet(&vector_table);
*(int *)0 = 0xffffffff;
while (1);
}
/*
* Reap keys of dead type.
*
* We use three flags to make sure we see three complete cycles of the garbage
* collector: the first to mark keys of that type as being dead, the second to
* collect dead links and the third to clean up the dead keys. We have to be
* careful as there may already be a cycle in progress.
*
* The caller must be holding key_types_sem.
*/
void key_gc_keytype(struct key_type *ktype)
{
kenter("%s", ktype->name);
key_gc_dead_keytype = ktype;
set_bit(KEY_GC_REAPING_KEYTYPE, &key_gc_flags);
smp_mb();
set_bit(KEY_GC_REAP_KEYTYPE, &key_gc_flags);
kdebug("schedule");
schedule_work(&key_gc_work);
kdebug("sleep");
wait_on_bit(&key_gc_flags, KEY_GC_REAPING_KEYTYPE, key_gc_wait_bit,
TASK_UNINTERRUPTIBLE);
key_gc_dead_keytype = NULL;
kleave("");
}
////////////////////////////////////////////////////
// 功能:
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
int DacClose(HANDLE hdac)
{
PDAC_DEVICE dac;
kMutexWait(hDacMutex);
dac = (PDAC_DEVICE)hdac;
kdebug(mod_audio, PRINT_INFO, "dac error data number = %d\n",nErrorData);
if(dac)
{
ListRemove(&dac->Link);
if(ListEmpty(&DacList))
{
//MillinsecoundDelay(20);
SetMuteMode(0);
//关闭功放
SetPowerAmplifier(0);
//MillinsecoundDelay(20);
SetMoseCe(0);
// 关闭耳机设备
DacHeadphoneClose();
// 关闭DA设备
DacDeviceClose();
// 没有这个耳机会有爆破音.
//MillinsecoundDelay(20);
}
DacDestorySamplerate(dac); //释放resample数据
DacDestoryWsola(hdac); //释放wsola数据
#ifdef DAC_SAVE_PCM
{
HANDLE fp;
fp = kfopen("d:\\pcm.bin","w+b");
kfwrite(dac_buf,1,dac_offset,fp);
kfclose(fp);
fp = kfopen("d:\\source.bin","w+b");
kfwrite(dac_source_buf,1,dac_source_offset,fp);
kfclose(fp);
}
#endif
kfree(dac);
kMutexRelease(hDacMutex);
return 0;
}
nErrorData = 0;
kMutexRelease(hDacMutex);
return -1;
}
void kmalloc_print()
{
malloc_block_t* ptr = first_block;
while (1) {
kdebug(" @%d, size=%d, flags=%b", ptr, ptr->size, ptr->flags);
if ((ptr->flags&MALLOC_LAST)!=0) {
break;
}
ptr = BLOCK_NEXT(ptr);
}
}
int Thread::try_detach()
{
/*
* We lock here because the joinable member might be cleared by the
* detach code
*/
rwlock_wrlock(&m_join_lock);
if (!m_joinable)
{
// Already detached so fail
rwlock_unlock(&m_join_lock);
kdebug("try_detach() not joinable\n");
return EINVAL;
}
m_joinable = 0;
if (m_joiner)
{
// Someone is already joining us we need to ready him
sys.m_sched.add(m_joiner, 0);
m_joiner = nullptr;
//abort();
// rwlock_unlock(&m_join_lock);
// kdebug("try_detach() already joined\n");
// return 0;
}
if (m_state == THR_ST_ZOMBIE)
{
// We are a zombie, ready to be reaped
kdebug("try_detach() THR_ST_ZOMBIE\n");
rwlock_unlock(&m_join_lock);
die();
return 0;
}
rwlock_unlock(&m_join_lock);
return 0;
}
int Syscall::kcall_threadregs(CoreData& core_data, Thread *currt) {
/*
* Read or write some thread data
*
* KPARM1 : pid
* KPARM2 : tid
* KPARM3 : *wr
* KPARM4 : *rd
*
* KRETVAL : 0 or -ERRNO
*/
Thread *target_thr;
regpack64_t *regpack_wr;
regpack64_t *regpack_rd;
struct _Anvil_tls *pptls_wr;
struct _Anvil_tls *pptls_rd;
if ((target_thr = get_thread_ref(KPARM1, KPARM2)) == NULL)
{
kdebug("kcall_threadregs got no thread %d %d\n", KPARM1, KPARM2);
return -ESRCH;
}
kdebug("kcall_threadregs %d %d %016lx\n", KPARM1, KPARM2, target_thr);
regpack_wr = (regpack64_t *)KPARM3;
regpack_rd = (regpack64_t *)KPARM4;
pptls_wr = (struct _Anvil_tls *)KPARM5;
pptls_rd = (struct _Anvil_tls *)KPARM6;
mm_ctx_set(target_thr->ctx);
kdebug("kcall_threadregs 1\n");
if (regpack_rd) {
*regpack_rd = target_thr->reg;
}
kdebug("kcall_threadregs 2\n");
if (regpack_wr) {
target_thr->reg = *regpack_wr;
}
if (pptls_rd) {
kdebug("kcall_threadregs 3 %016lx\n", target_thr->pptls);
memcpy(pptls_rd, *(target_thr->pptls), sizeof(struct _Anvil_tls));
}
if (pptls_wr) {
kdebug("kcall_threadregs 4 %016lx\n", target_thr->pptls);
memcpy(*(target_thr->pptls), pptls_wr, sizeof(struct _Anvil_tls) - sizeof(void *));
}
kdebug("kcall_threadregs done !!\n");
target_thr->unref();
return 0;
}
void *malloc(size_t size)
{
void *addr;
if (size > MAXSIZE_ALLOC || !(addr = kmalloc(size, GFP_KERNEL))) {
kdebug("kmalloc size %x err, too large\n", size);
set_error(STATUS_NO_MEMORY);
return NULL;
}
return addr;
}
