/**
* 更新好友信息数据.
* @param pal 好友数据
*/
void UdpData::UpdatePalInfo(PalInfo *pal)
{
g_free(pal->segdes);
pal->segdes = progdt.FindNetSegDescription(ipv4);
g_free(pal->version);
if (!(pal->version = iptux_get_section_string(buf, ':', 0)))
pal->version = g_strdup("?");
g_free(pal->user);
if (!(pal->user = iptux_get_section_string(buf, ':', 2)))
pal->user = g_strdup("???");
g_free(pal->host);
if (!(pal->host = iptux_get_section_string(buf, ':', 3)))
pal->host = g_strdup("???");
if (!FLAG_ISSET(pal->flags, 2)) {
g_free(pal->name);
if (!(pal->name = ipmsg_get_attach(buf, ':', 5)))
pal->name = g_strdup(_("mysterious"));
g_free(pal->group);
pal->group = GetPalGroup();
g_free(pal->iconfile);
if (!(pal->iconfile = GetPalIcon()))
pal->iconfile = g_strdup(progdt.palicon);
FLAG_CLR(pal->flags, 0);
g_free(pal->encode);
if ( (pal->encode = GetPalEncode()))
FLAG_SET(pal->flags, 0);
else
pal->encode = g_strdup(encode ? encode : "utf-8");
}
FLAG_SET(pal->flags, 1);
pal->packetn = 0;
pal->rpacketn = 0;
}
/**
* 创建好友信息数据.
* @return 好友数据
*/
PalInfo *UdpData::CreatePalInfo()
{
PalInfo *pal;
pal = new PalInfo;
pal->ipv4 = ipv4;
pal->segdes = progdt.FindNetSegDescription(ipv4);
if (!(pal->version = iptux_get_section_string(buf, ':', 0)))
pal->version = g_strdup("?");
if (!(pal->user = iptux_get_section_string(buf, ':', 2)))
pal->user = g_strdup("???");
if (!(pal->host = iptux_get_section_string(buf, ':', 3)))
pal->host = g_strdup("???");
if (!(pal->name = ipmsg_get_attach(buf, ':', 5)))
pal->name = g_strdup(_("mysterious"));
pal->group = GetPalGroup();
pal->photo = NULL;
pal->sign = NULL;
if (!(pal->iconfile = GetPalIcon()))
pal->iconfile = g_strdup(progdt.palicon);
if ( (pal->encode = GetPalEncode()))
FLAG_SET(pal->flags, 0);
else
pal->encode = g_strdup(encode ? encode : "utf-8");
FLAG_SET(pal->flags, 1);
pal->packetn = 0;
pal->rpacketn = 0;
return pal;
}
static void
clientAutoMaximize (Client * c, int full_w, int full_h)
{
if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN) ||
!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER))
{
/*
* Fullscreen or undecorated windows should not be
* automatically maximized...
*/
return;
}
if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ) &&
(frameWidth (c) > full_w))
{
TRACE ("The application \"%s\" has requested a window width "
"(%u) larger than the actual width available in the workspace (%u), "
"the window will be maximized horizontally.", c->name, frameWidth (c), full_w);
FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ);
}
if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_VERT) &&
(frameHeight (c) > full_h))
{
TRACE ("The application \"%s\" has requested a window height "
"(%u) larger than the actual height available in the workspace (%u), "
"the window will be maximized vertically.", c->name, frameHeight (c), full_h);
FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_VERT);
}
}
tail_recursion_elimination ()
{
int alt;
int tre = 0;
if (no_recursion_elm_flag)
return false;
for (alt = SON (ulhs); alt != nil; alt = BROTHER (alt))
{
int mem = SON (alt);
if (mem == nil)
continue;
if (FLAG_MARKED (alt, no_tail_recursion_opt_f))
continue;
mem = get_last_but_cut_mem (mem);
if (DEF (mem) == ulhs)
{
FLAG_SET (alt, tail_recursion_opt_f);
FLAG_SET (mem, tail_recursion_opt_f);
tre = 1;
}
}
return tre;
}
/*
* Set Handle Features
*/
int nvmed_handle_feature_set(NVMED_HANDLE* nvmed_handle, int feature, int value) {
switch(feature) {
case HANDLE_DIRECT_IO:
if(value)
FLAG_SET(nvmed_handle, HANDLE_DIRECT_IO);
else
FLAG_UNSET(nvmed_handle, HANDLE_DIRECT_IO);
break;
case HANDLE_SYNC_IO:
if(value)
FLAG_SET(nvmed_handle, HANDLE_SYNC_IO);
else
FLAG_UNSET(nvmed_handle, HANDLE_SYNC_IO);
break;
case HANDLE_HINT_DMEM:
if(value)
FLAG_SET(nvmed_handle, HANDLE_HINT_DMEM);
else
FLAG_UNSET(nvmed_handle, HANDLE_HINT_DMEM);
break;
}
return value;
}
void USB_Init(void)
{
extern uint32 __VECTOR_RAM[];
/* Software Configuration */
Setup_Pkt=(tUSB_Setup*)BufferPointer[bEP0OUT_ODD];
gu8USB_State=uPOWER;
/* MPU Configuration */
MPU_CESR=0; // MPU is disable. All accesses from all bus masters are allowed
/* SIM Configuration */
#ifdef USB_CLOCK_CLKIN
FLAG_SET(SIM_SCGC5_PORTE_SHIFT,SIM_SCGC5);
PORTE_PCR26=(0|PORT_PCR_MUX(7)); // Enabling PTE26 as CLK input
#endif
#ifdef USB_CLOCK_PLL
FLAG_SET(SIM_SOPT2_PLLFLLSEL_SHIFT,SIM_SOPT2); // Select PLL output
#endif
#ifndef USB_CLOCK_CLKIN
FLAG_SET(SIM_SOPT2_USBSRC_SHIFT,SIM_SOPT2); // PLL/FLL selected as CLK source
#endif
SIM_CLKDIV2|=USB_FARCTIONAL_VALUE; // USB Freq Divider
SIM_SCGC4|=(SIM_SCGC4_USBOTG_MASK); // USB Clock Gating
/* NVIC Configuration */
__VECTOR_RAM[89]=(UINT32)USB_ISR; //replace ISR
//NVICICER2|=(1<<9); //Clear any pending interrupts on USB
NVICISER2|=(1<<9); //Enable interrupts from USB module
/* USB Module Configuration */
// Reset USB Module
USB0_USBTRC0|=USB_USBTRC0_USBRESET_MASK;
while(FLAG_CHK(USB_USBTRC0_USBRESET_SHIFT,USB0_USBTRC0)){};
// Set BDT Base Register
USB0_BDTPAGE1=(UINT8)((UINT32)tBDTtable>>8);
USB0_BDTPAGE2=(UINT8)((UINT32)tBDTtable>>16);
USB0_BDTPAGE3=(UINT8)((UINT32)tBDTtable>>24);
// Clear USB Reset flag
FLAG_SET(USB_ISTAT_USBRST_MASK,USB0_ISTAT);
// Enable USB Reset Interrupt
FLAG_SET(USB_INTEN_USBRSTEN_SHIFT,USB0_INTEN);
// Enable weak pull downs
USB0_USBCTRL=0x40;
USB0_USBTRC0|=0x40;
USB0_CTL|=0x01;
}
void USB_Reset_Handler(void)
{
//PMC_VLPR_Exit();
/* Software Flags */
u8CDCState=0;
gu8USBClearFlags=0xFF;
gu8USB_Toogle_flags=0;
gu8USB_PingPong_flags=0x00;
/* Disable all data EP registers */
USB0_ENDPT1=0x00;
USB0_ENDPT2=0x00;
USB0_ENDPT3=0x00;
USB0_ENDPT4=0x00;
USB0_ENDPT5=0x00;
USB0_ENDPT6=0x00;
/* EP0 BDT Setup */
// EP0 OUT BDT Settings
tBDTtable[bEP0OUT_ODD].Cnt = EP0_SIZE;
tBDTtable[bEP0OUT_ODD].Addr =(UINT32)gu8EP0_OUT_ODD_Buffer;
tBDTtable[bEP0OUT_ODD].Stat._byte = kUDATA1;
// EP0 OUT BDT Settings
tBDTtable[bEP0OUT_EVEN].Cnt = EP0_SIZE;
tBDTtable[bEP0OUT_EVEN].Addr =(UINT32)gu8EP0_OUT_EVEN_Buffer;
tBDTtable[bEP0OUT_EVEN].Stat._byte = kUDATA1;
// EP0 IN BDT Settings
tBDTtable[bEP0IN_ODD].Cnt = EP0_SIZE;
tBDTtable[bEP0IN_ODD].Addr =(UINT32)gu8EP0_IN_ODD_Buffer;
tBDTtable[bEP0IN_ODD].Stat._byte = kUDATA0;
// EP0 IN BDT Settings
tBDTtable[bEP0IN_EVEN].Cnt = (EP0_SIZE);
tBDTtable[bEP0IN_EVEN].Addr =(UINT32)gu8EP0_IN_EVEN_Buffer;
tBDTtable[bEP0IN_EVEN].Stat._byte = kUDATA0;
// Enable EP0
USB0_ENDPT0=0x0D;
// Clear all Error flags
USB0_ERRSTAT=0xFF;
// CLear all USB ISR flags
USB0_ISTAT=0xFF;
// Set default Address
USB0_ADDR=0x00;
// Enable all error sources
USB0_ERREN=0xFF;
// USB Interrupt Enablers
FLAG_SET(USB_INTEN_TOKDNEEN_SHIFT,USB0_INTEN);
FLAG_SET(USB_INTEN_SOFTOKEN_SHIFT,USB0_INTEN);
FLAG_SET(USB_INTEN_ERROREN_SHIFT,USB0_INTEN);
FLAG_SET(USB_INTEN_USBRSTEN_SHIFT,USB0_INTEN);
}
/*
* Allocation cache slot and memory
*/
int nvmed_cache_alloc(NVMED* nvmed, unsigned int size, bool lazy_init) {
int i;
unsigned int req_size;
NVMED_CACHE_SLOT *slot;
NVMED_CACHE *info;
u64 *paList;
pthread_spin_lock(&nvmed->mngt_lock);
if(size == 0) return -NVMED_FAULT;
if(size == nvmed->num_cache_size) return 0;
if(size < nvmed->num_cache_size) {
nvmed_printf("%s: Cache shrinking is not supported\n", nvmed->ns_path);
return -NVMED_FAULT;
}
req_size = size - nvmed->num_cache_size;
slot = malloc(sizeof(NVMED_CACHE_SLOT));
slot->cache_info = malloc(sizeof(NVMED_CACHE) * req_size);
slot->cache_ptr = mmap(NULL, PAGE_SIZE * req_size, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_LOCKED | MAP_SHARED, -1, 0);
slot->size = req_size;
LIST_INSERT_HEAD(&nvmed->slot_head, slot, slot_list);
/* Initialize memory and translate virt to phys addr */
if(!lazy_init) {
paList = malloc(sizeof(u64) * req_size);
virt_to_phys(nvmed, slot->cache_ptr, paList, PAGE_SIZE * req_size);
}
/* fill cache info and add to free list */
for(i=0; i<req_size; i++) {
info = slot->cache_info + i;
info->lpaddr = 0;
info->ref = 0;
if(lazy_init == false) {
info->paddr = paList[i];
FLAG_SET(info, CACHE_FREE);
}
else {
info->paddr = 0;
FLAG_SET(info, CACHE_UNINIT | CACHE_FREE);
}
info->ptr = slot->cache_ptr + (i*PAGE_SIZE);
TAILQ_INSERT_HEAD(&nvmed->free_head, info, cache_list);
}
nvmed->num_cache_size = size;
pthread_spin_unlock(&nvmed->mngt_lock);
return req_size;
}
//=========================================================================
//函数名: hw_usb_reset_handler
//功 能: 处理复位中断
//参 数: 无
//返 回: 无
//=========================================================================
void hw_usb_reset_handler(void)
{
//清标志
gu8USBClearFlags=0xFF;
gu8USB_Toogle_flags=0;
//禁止所有端点
USB0_ENDPT1=0x00;
USB0_ENDPT2=0x00;
USB0_ENDPT3=0x00;
USB0_ENDPT4=0x00;
USB0_ENDPT5=0x00;
USB0_ENDPT6=0x00;
// EP0 BDT Setup
// EP0 OUT BDT 设置
tBDTtable[bEP0OUT_ODD].Cnt = EP0_SIZE;
tBDTtable[bEP0OUT_ODD].Addr =(uint_32)gu8EP0_OUT_ODD_Buffer;
tBDTtable[bEP0OUT_ODD].Stat._byte = kUDATA1;
// EP0 OUT BDT 设置
tBDTtable[bEP0OUT_EVEN].Cnt = EP0_SIZE;
tBDTtable[bEP0OUT_EVEN].Addr =(uint_32)gu8EP0_OUT_EVEN_Buffer;
tBDTtable[bEP0OUT_EVEN].Stat._byte = kUDATA1;
// EP0 IN BDT 设置
tBDTtable[bEP0IN_ODD].Cnt = EP0_SIZE;
tBDTtable[bEP0IN_ODD].Addr =(uint_32)gu8EP0_IN_ODD_Buffer;
tBDTtable[bEP0IN_ODD].Stat._byte = kUDATA0;
// EP0 IN BDT 设置
tBDTtable[bEP0IN_EVEN].Cnt = (EP0_SIZE);
tBDTtable[bEP0IN_EVEN].Addr =(uint_32)gu8EP0_IN_EVEN_Buffer;
tBDTtable[bEP0IN_EVEN].Stat._byte = kUDATA0;
// 使能 EP0
USB0_ENDPT0=0x0D;
// 清除所有的错误
USB0_ERRSTAT=0xFF;
// 清除所有的中断标志
USB0_ISTAT=0xFF;
// USB设备地址
USB0_ADDR=0x00;
// 使能所有的错误中断
USB0_ERREN=0xFF;
// USB模块中断使能
FLAG_SET(USB_INTEN_TOKDNEEN_SHIFT,USB0_INTEN);
FLAG_SET(USB_INTEN_SOFTOKEN_SHIFT,USB0_INTEN);
FLAG_SET(USB_INTEN_ERROREN_SHIFT,USB0_INTEN);
FLAG_SET(USB_INTEN_USBRSTEN_SHIFT,USB0_INTEN);
}
void _bsp_platform_init(void)
{
/* MPU Configuration */
MPU_CESR=0; // MPU is disable. All accesses from all bus masters are allowed
/* SIM Configuration */
FLAG_SET(SIM_SOPT2_USBSRC_SHIFT,SIM_SOPT2); // PLL/FLL selected as CLK source
FLAG_SET(SIM_SOPT2_PLLFLLSEL_SHIFT,SIM_SOPT2); // Select PLL output
SIM_CLKDIV2=0x02; // USB Freq Divider
SIM_SCGC4|=(SIM_SCGC4_USBOTG_MASK); // USB Clock Gating
// weak pulldowns
USB0_USBCTRL=0x40;
}
//=========================================================================
//函数名: hw_usb_endpoint_setup_handler
//功 能: 当主机请求接口配置请求时，执行该函数
//参 数: 无
//返 回: 无
//=========================================================================
void hw_usb_endpoint_setup_handler(void)
{
uint_16 u16Status;
switch(Setup_Pkt->bRequest)
{
case GET_STATUS:
if(FLAG_CHK(Setup_Pkt->wIndex_h,gu8HALT_EP))
u16Status=0x0100;
else
u16Status=0x0000;
hw_usb_ep_in_transfer(EP0,(uint_8*)&u16Status,2);
break;
case CLEAR_FEATURE:
FLAG_CLR(Setup_Pkt->wIndex_h,gu8HALT_EP);
hw_usb_ep_in_transfer(EP0,0,0);
break;
case SET_FEATURE:
FLAG_SET(Setup_Pkt->wIndex_h,gu8HALT_EP);
hw_usb_ep_in_transfer(EP0,0,0);
break;
default:
break;
}
}
void vfnInitUSBClock (uint8_t u8ClkOption)
{
switch (u8ClkOption)
{
case MCGPLL0:
{
SIM_SOPT2 |= SIM_SOPT2_PLLFLLSEL_MASK /** PLL reference */
| SIM_SOPT2_USBSRC_MASK; /** USB clock source MCGPLLCLK/2 or MCGFLLCLK */
break;
}
case MCGFLL:
{
/** Configure FLL to generate a 48MHz core clock */
fll_init();
SIM_SOPT2 &= ~SIM_SOPT2_PLLFLLSEL_MASK; /** FLL reference */
SIM_SOPT2 |= SIM_SOPT2_USBSRC_MASK; /** USB clock source MCGPLLCLK/2 or MCGFLLCLK */
break;
}
case CLKIN:
{
SIM_SOPT2 &= (uint32_t)(~SIM_SOPT2_USBSRC_MASK); /** PTA5 selected as USBFS CLK source */
FLAG_SET(SIM_SCGC5_PORTA_SHIFT,SIM_SCGC5);
PORTA_PCR5=(0|PORT_PCR_MUX(2)); /** Enable PTA5 as CLK input */
}
}
SIM_SCGC4|=(SIM_SCGC4_USBOTG_MASK); // USB Clock Gating
}
void block_store_link(block_store_t *const bs, const char *const filename) {
if (bs && filename) {
if (! FLAG_CHECK(bs, FILE_LINKED)) {
// Ok, I can make a giant complicated hunk of logic to:
// Create if it doesn't exist
// Increase size if smaller
// Decrease size if larger
// and It'll be a giant headache for various reasons (error checking, portability)
// OR, I can just do it in two commands and call it a day.
bs->fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP);
if (bs->fd != -1) {
if (utility_write_file(bs->fd, bs->data_blocks, BLOCK_COUNT * BLOCK_SIZE) == BLOCK_COUNT * BLOCK_SIZE) {
// Kill the DBM and dirty flag, set link state
bitmap_format(bs->dbm, 0x00);
FLAG_CLEAR(bs, DIRTY);
FLAG_SET(bs, FILE_LINKED);
bs_errno = BS_OK;
return;
}
bs_errno = BS_FILE_IO;
return;
}
bs_errno = BS_FILE_ACCESS;
return;
}
bs_errno = BS_LINK_EXISTS;
return;
}
bs_errno = BS_PARAM;
}
void I8254Pit::writePeriodicIo(void)
{
state.lock.acquire();
io::write8(
i8254_CHAN0_IO_CONTROL,
i8254_CHAN0_CONTROL_SELECT_COUNTER
| i8254_CHAN0_CONTROL_MODE2_RATEGEN
| i8254_CHAN0_CONTROL_COUNTER_WRITE_LOWHIGH);
atomicAsm::memoryBarrier();
// Write out the currently set periodic rate.
io::write8(
i8254_CHAN0_IO_COUNTER,
i8254State.currentIntervalClks & 0xFF);
io::write8(
i8254_CHAN0_IO_COUNTER,
i8254State.currentIntervalClks >> 8);
FLAG_SET(
state.rsrc.flags,
ZKCM_TIMERDEV_STATE_FLAGS_ENABLED
| ZKCM_TIMERDEV_STATE_FLAGS_SOFT_ENABLED);
state.lock.release();
}
int esys_isolate(struct esys* esys, ocn_entity_token_t token, entity_t** entity)
{
if(token >= OCN_MAX_ENTITIES)
return OCN_ENTITY_ERR_RANGE;
*entity = NULL;
pthread_spin_lock(&esys->lock);
struct entityslot* slot = &esys->slots[token];
if(!FLAG_GET(slot->flags, ENTITYSLOT_FLAG_USED))
{
pthread_spin_unlock(&esys->lock);
return OCN_ENTITY_ERR_NONEXIST;
}
if(FLAG_GET(slot->flags, ENTITYSLOT_FLAG_ISOLATED))
{
pthread_spin_unlock(&esys->lock);
return OCN_ENTITY_ERR_ISOLATED;
}
/* --- */
FLAG_SET(slot->flags, ENTITYSLOT_FLAG_ISOLATED);
*entity = &slot->entity;
/* --- */
pthread_spin_unlock(&esys->lock);
return OCN_OK;
}
static int sudoku_get(const char *filename)
{
int fd;
int i, j;
char buf[10];
fd = open(filename, O_RDONLY);
if (fd == -1) {
printf("open %s error!\n", filename);
getch();
exit(-1);
}
for (i = 0; i < 9; i++) {
read(fd, buf, 10);
for (j = 0; j < 9; j++) {
if ((buf[j] >= '0') && (buf[j] <= '9')) {
sudoku[i][j].data = buf[j] - '0';
sudoku[i][j].flag = FLAG_SET(buf[j] - '0');
} else {
printf("ERROR - Please check origin data\n");
getch();
exit(-1);
}
}
}
if (fd)
close(fd);
return 0;
}
int esys_add(struct esys* esys, ocn_entity_token_t* token, ocn_entity_type_t type)
{
if(token == NULL)
return OCN_FAIL;
/* generate token */
if(esys_token(esys, token) != OCN_OK)
return OCN_ENTITY_ERR_MAX;
/* we do not need to lock here,
because nobody can possibly
know this token by now. */
if(entity_init(&esys->slots[*token].entity, type) != OCN_OK)
return OCN_ENTITY_ERR_INIT;
pthread_spin_lock(&esys->lock);
/* --- */
FLAG_SET(esys->slots[*token].flags, ENTITYSLOT_FLAG_USED);
/* --- */
pthread_spin_unlock(&esys->lock);
return OCN_OK;
}
/*!
* @brief 当前接口请求为CDC类请求 的 中断复位函数
* @note 在 USB_Setup_Handler 中断里调用
* @since v5.0
*/
uint8 CDC_InterfaceReq_Handler(void)
{
uint8 u8State = uSETUP;
switch(Setup_Pkt->bRequest)
{
case GET_INTERFACE:
EP_IN_Transfer(EP0, &gu8Interface, 1);
break;
case GET_LINE_CODING:
EP_IN_Transfer(EP0, (uint8 *)&com_cfg, 7);
break;
case SET_LINE_CODING:
u8CDCState = SET_LINE_CODING;
u8State = uDATA;
break;
case SET_CONTROL_LINE_STATE:
u8CDCState = SET_CONTROL_LINE_STATE;
u8State = uSETUP;
break;
case LOADER_MODE:
FLAG_SET(LOADER, gu8USB_Flags);
CDC_OUT_Data[0] = 0xFF;
break;
default:
break;
}
return(u8State);
}
int rsys_worker_req_add(struct rsys* rsys, ocn_entity_token_t token, entity_t* entity)
{
rsys_req_t* req = ocn_malloc(sizeof(rsys_req_t));
req->flags = 0;
FLAG_SET(req->flags, RSYS_REQ_RENDERER);
req->type = RSYS_REQ_TYPE_ADD;
req->token = token;
switch(entity->type)
{
case ENTITY_TYPE_NONE:
break;
case ENTITY_TYPE_CAMERA:
break;
case ENTITY_TYPE_POINTLIGHT:
break;
case ENTITY_TYPE_STATIC_MESH:
break;
default:
break;
}
return rsys_worker_req(rsys, req);
}
/**
* 好友信息数据丢失默认处理函数.
* 若xx并不在好友列表中，但是程序却期望能够接受xx的本次会话，
* 所以必须以默认数据构建好友信息数据并插入好友列表 \n
*/
void UdpData::SomeoneLost()
{
PalInfo *pal;
/* 创建好友数据 */
pal = new PalInfo;
pal->ipv4 = ipv4;
pal->segdes = progdt.FindNetSegDescription(ipv4);
if (!(pal->version = iptux_get_section_string(buf, ':', 0)))
pal->version = g_strdup("?");
if (!(pal->user = iptux_get_section_string(buf, ':', 2)))
pal->user = g_strdup("???");
if (!(pal->host = iptux_get_section_string(buf, ':', 3)))
pal->host = g_strdup("???");
pal->name = g_strdup(_("mysterious"));
pal->group = g_strdup(_("mysterious"));
pal->photo = NULL;
pal->sign = NULL;
pal->iconfile = g_strdup(progdt.palicon);
pal->encode = g_strdup(encode ? encode : "utf-8");
FLAG_SET(pal->flags, 1);
pal->packetn = 0;
pal->rpacketn = 0;
/* 加入好友列表 */
gdk_threads_enter();
pthread_mutex_lock(cthrd.GetMutex());
cthrd.AttachPalToList(pal);
pthread_mutex_unlock(cthrd.GetMutex());
mwin.AttachItemToPaltree(ipv4);
gdk_threads_leave();
}
void
clientInitFocusFlag (Client * c)
{
ScreenInfo *screen_info;
Client *c2;
GList *list;
guint workspace;
g_return_if_fail (c != NULL);
TRACE ("client \"%s\" (0x%lx)", c->name, c->window);
if (!clientAcceptFocus (c) || (c->type & WINDOW_TYPE_DONT_FOCUS))
{
return;
}
screen_info = c->screen_info;
workspace = c->win_workspace;
for (list = screen_info->windows_stack; list; list = g_list_next (list))
{
c2 = (Client *) list->data;
if ((c2->win_workspace == workspace) && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_FOCUS))
{
FLAG_UNSET (c2->xfwm_flags, XFWM_FLAG_FOCUS);
}
}
FLAG_SET (c->xfwm_flags, XFWM_FLAG_FOCUS);
}
void I8254Pit::writeOneshotIo(void)
{
/** NOTE:
* Interesting note here, Linux seems to use mode 4 for the oneshot
* timer (Software retriggerable strobe).
**/
state.lock.acquire();
// Write out the oneshot mode (mode 0) control byte.
io::write8(
i8254_CHAN0_IO_CONTROL,
i8254_CHAN0_CONTROL_SELECT_COUNTER
| i8254_CHAN0_CONTROL_MODE0_ONESHOT
| i8254_CHAN0_CONTROL_COUNTER_WRITE_LOWHIGH);
atomicAsm::memoryBarrier();
// Write out the number of ns converted into i8254 CLK pulse equiv time.
io::write8(
i8254_CHAN0_IO_COUNTER,
i8254State.currentTimeoutClks & 0xFF);
io::write8(
i8254_CHAN0_IO_COUNTER,
i8254State.currentTimeoutClks >> 8);
FLAG_SET(
state.rsrc.flags,
ZKCM_TIMERDEV_STATE_FLAGS_ENABLED
| ZKCM_TIMERDEV_STATE_FLAGS_SOFT_ENABLED);
state.lock.release();
}
void USB_Endpoint_Setup_Handler(void)
{
UINT16 u16Status;
switch(Setup_Pkt->bRequest)
{
case GET_STATUS:
if(FLAG_CHK(Setup_Pkt->wIndex_h,gu8HALT_EP))
u16Status=0x0100;
else
u16Status=0x0000;
EP_IN_Transfer(EP0,(UINT8*)&u16Status,2);
break;
case CLEAR_FEATURE:
FLAG_CLR(Setup_Pkt->wIndex_h,gu8HALT_EP);
EP_IN_Transfer(EP0,0,0);
break;
case SET_FEATURE:
FLAG_SET(Setup_Pkt->wIndex_h,gu8HALT_EP);
EP_IN_Transfer(EP0,0,0);
break;
default:
break;
}
}
UINT8 CDC_InterfaceReq_Handler(void)
{
UINT8 u8State=uSETUP;
switch(Setup_Pkt->bRequest)
{
case GET_INTERFACE:
EP_IN_Transfer(EP0,&gu8Interface,1);
break;
case GET_LINE_CODING:
EP_IN_Transfer(EP0,(UINT8*)&LineCoding,7);
break;
case SET_LINE_CODING:
u8CDCState=SET_LINE_CODING;
u8State=uDATA;
break;
case SET_CONTROL_LINE_STATE:
u8CDCState=SET_CONTROL_LINE_STATE;
u8State=uSETUP;
break;
case LOADER_MODE:
Buffer_Init(CDC_OUT_Data,CDC_BUFFER_SIZE);
FLAG_SET(LOADER,gu8USB_Flags);
CDC_OUT_Data[0]=0xFF;
break;
}
return(u8State);
}
//=========================================================================
//函数名: hw_usb_init
//功 能: USB模块初始
//参 数: 无
//返 回: 无
//=========================================================================
void hw_usb_init(void)
{
tBDTtable = (tBDT *)((( uint_32 ) tBDT_unaligned & 0xFFFFFE00UL)+ 0x200UL);
Setup_Pkt=(tUSB_Setup*)BufferPointer[bEP0OUT_ODD];
gu8USB_State=uPOWER;
//USB_FMC_ACC_ENABLE;
USB_REG_SET_ENABLE;
USB_REG_CLEAR_STDBY;
//MPU_CESR=0;//禁止MPU
FLAG_SET(SIM_SOPT2_PLLFLLSEL_SHIFT,SIM_SOPT2); // 使能PLL输出
FLAG_SET(SIM_SOPT2_USBSRC_SHIFT,SIM_SOPT2); // 使能PLL/FLL为时钟源
//SIM_CLKDIV2|=USB_FARCTIONAL_VALUE; //USB分频因子设置
SIM_SCGC4|=(SIM_SCGC4_USBOTG_MASK); //USB模块时钟门使能
enable_irq(USB_INTERRUPT_IRQ); //使能USB模块IRQ中断
//USB模块寄存器配置
USB0_USBTRC0|=USB_USBTRC0_USBRESET_MASK; //复位USB模块
while(FLAG_CHK(USB_USBTRC0_USBRESET_SHIFT,USB0_USBTRC0)){};
//设置BDT基址寄存器
//( 低9 位是默认512 字节的偏移) 512 = 16 * 4 * 8 。
//8 位表示: 4 个字节的控制状态，4 个字节的缓冲区地址 。
USB0_BDTPAGE1=(uint_8)((uint_32)tBDTtable>>8);
USB0_BDTPAGE2=(uint_8)((uint_32)tBDTtable>>16);
USB0_BDTPAGE3=(uint_8)((uint_32)tBDTtable>>24);
//清除USB模块复位标志
FLAG_SET(USB_ISTAT_USBRST_MASK,USB0_ISTAT);
//使能USB模块复位中断
FLAG_SET(USB_INTEN_USBRSTEN_SHIFT,USB0_INTEN);
USB0_USBCTRL=0x40;
USB0_USBTRC0|=0x40; //强制设置第6位为1
USB0_CTL|=0x01; //USB模块使能
//上拉使能
FLAG_SET(USB_CONTROL_DPPULLUPNONOTG_SHIFT,USB0_CONTROL);
}
void USB_Init(void)
{
/* Software Configuration */
Setup_Pkt=(tUSB_Setup*)BufferPointer[bEP0OUT_ODD];
gu8USB_State=uPOWER;
/* MPU Configuration */
// MPU_CESR=0; MPU is disable. All accesses from all bus masters are allowed
/** Feed 48MHz to the USB FS clock */
vfnInitUSBClock(USB_CLOCK);
/* NVIC Configuration */
extern uint32 __VECTOR_RAM[]; //Get vector table that was copied to RAM
__VECTOR_RAM[40]=(uint32)USB_ISR; //replace ISR
enable_irq(24); //IRQ 24 for USBOTG and USBCDC on L2K
/* USB Module Configuration */
// Reset USB Module
USB0_USBTRC0 |= USB_USBTRC0_USBRESET_MASK;
while(FLAG_CHK(USB_USBTRC0_USBRESET_SHIFT,USB0_USBTRC0)) {};
// Set BDT Base Register
USB0_BDTPAGE1=(uint8)((uint32)tBDTtable>>8);
USB0_BDTPAGE2=(uint8)((uint32)tBDTtable>>16);
USB0_BDTPAGE3=(uint8)((uint32)tBDTtable>>24);
// Clear USB Reset flag
FLAG_SET(USB_ISTAT_USBRST_MASK,USB0_ISTAT);
// Enable USB Reset Interrupt
FLAG_SET(USB_INTEN_USBRSTEN_SHIFT,USB0_INTEN);
// Enable weak pull downs
//USB0_USBCTRL = USB_USBCTRL_PDE_MASK;
// Disable weak pull downs
USB0_USBCTRL &= ~(uint8)(USB_USBCTRL_PDE_MASK | USB_USBCTRL_SUSP_MASK);
USB0_USBTRC0|=0x40;
USB0_CTL|=0x01;
// Pull up enable
FLAG_SET(USB_CONTROL_DPPULLUPNONOTG_SHIFT,USB0_CONTROL);
}
void usb_init(void)
{
//printf("\n********** USB XCVR Module Testing **********\n");
USB_REG_SET_ENABLE;
CDC_Init();
// Pull up enable
FLAG_SET(USB_CONTROL_DPPULLUPNONOTG_SHIFT,USB0_CONTROL);
}
void MAX3353_ISR(void)
{
// Clear the Interrupt pending flag
gu8MAX3353StatusRegister=I2C_ReadRegister(MAX3353_I2C_ADDRESS,MAX3353_REG_INT_LATCH);
// Set MAX3353 ISR flag
FLAG_SET(_MAX3353,gu8ISR_Flags);
}
void USB_EP0_Stall(void)
{
FLAG_SET(USB_ENDPT_EPSTALL_SHIFT,USB0_ENDPT0);
//ENDPT0_EP_STALL = 1;
tBDTtable[bEP0OUT_ODD].Stat._byte = kUDATA0;
tBDTtable[bEP0OUT_ODD].Cnt = EP0_SIZE;
}
//=========================================================================
//函数名: hw_usb_isr
//功 能: 处理复位中断
//参 数: 无
//返 回: 无
//=========================================================================
void hw_usb_isr(void)
{
// 检测USB 模块是否解析到有效的复位。
if(FLAG_CHK(USB_ISTAT_USBRST_SHIFT,USB0_ISTAT))
{
hw_usb_reset_handler();
return;
}
if(FLAG_CHK(USB_ISTAT_SOFTOK_SHIFT,USB0_ISTAT))
{
USB0_ISTAT = USB_ISTAT_SOFTOK_MASK;
}
// 检测STALL
if(FLAG_CHK(USB_ISTAT_STALL_SHIFT,USB0_ISTAT))
{
hw_usb_stall_handler();
}
// 令牌完成中断
if(FLAG_CHK(USB_ISTAT_TOKDNE_SHIFT,USB0_ISTAT))
{
FLAG_SET(USB_CTL_ODDRST_SHIFT,USB0_CTL);
// USB 处理函数
hw_usb_handler();
// 清除令牌完成中断
FLAG_SET(USB_ISTAT_TOKDNE_SHIFT,USB0_ISTAT);
}
// SLEEP
if(FLAG_CHK(USB_ISTAT_SLEEP_SHIFT,USB0_ISTAT))
{
// 清除SLEEP中断
FLAG_SET(USB_ISTAT_SLEEP_SHIFT,USB0_ISTAT);
}
// 错误
if(FLAG_CHK(USB_ISTAT_ERROR_SHIFT,USB0_ISTAT))
{
FLAG_SET(USB_ISTAT_ERROR_SHIFT,USB0_ISTAT);
}
}
