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; }