void INIT_ATTR headphone_init(void) { /* A thread is required to monitor the remote ADC and jack state. */ semaphore_init(&headphone_wakeup, 1, 0); headphone_thread_id = create_thread(headphone_thread, headphone_stack, sizeof(headphone_stack), 0, headphone_thread_name IF_PRIO(, PRIORITY_REALTIME) IF_COP(, CPU)); /* Initially poll and then enable PMIC event */ headphone_detect_event(); mc13783_enable_event(MC13783_ONOFD2_EVENT); }
void kmain() { irq_disable(); /* * A primeira coisa a se fazer é iniciar todo o gerenciador * de memória. */ mm_init(); arch_early_init(); ioremap_init(); irq_init(); sched_init(); timer_init(); /* * Neste momento temos o gerenciador de memória e escalonador prontos, * já podemos habilitar as interrupções, que podem ser utilizadas * pelos drivers. */ irq_enable(); /* Inicia os drivers da plataforma */ arch_setup(); /* Requisita um modo se existir um framebuffer*/ fb_set_mode(); /* Inicia o console sobre o framebuffer */ fb_console_init(); kernel_info(); #if 1 irq_disable(); semaphore_init(&sem, 1); create_task("a", 4); create_task("b", 5); create_task("c", 6); create_task("d", 7); create_task("b", 8); create_task("b", 9); irq_enable(); /* Fica de boas esperando as trocas de contexto */ #endif /* Como queremos imprimir para depuração do driver, inicializamos ele agora */ //bcm2835_emmc_init(); for (;;) { led_blink(); //printk("-"); } }
void imx233_lradc_init(void) { mutex_init(&free_bm_mutex); semaphore_init(&free_bm_sema, HW_LRADC_NUM_CHANNELS, HW_LRADC_NUM_CHANNELS); free_bm = (1 << HW_LRADC_NUM_CHANNELS) - 1; // enable block imx233_reset_block(&HW_LRADC_CTRL0); // disable ground ref __REG_CLR(HW_LRADC_CTRL0) = HW_LRADC_CTRL0__ONCHIP_GROUNDREF; // disable temperature sensors __REG_CLR(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__TEMP_SENSOR_IENABLE0 | HW_LRADC_CTRL2__TEMP_SENSOR_IENABLE1; __REG_SET(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__TEMPSENSE_PWD; // set frequency __REG_CLR(HW_LRADC_CTRL3) = HW_LRADC_CTRL3__CYCLE_TIME_BM; __REG_SET(HW_LRADC_CTRL3) = HW_LRADC_CTRL3__CYCLE_TIME__6MHz; }
/* Allocate a basic TSS */ static uint16 alloc_TSS (void *pPageDirectory, void *pEntry, int mod_num) { int i; descriptor *ad = (idt + 256); /* Get address of GDT from IDT address */ quest_tss *pTSS = (quest_tss *) ul_tss[mod_num]; /* Search 2KB GDT for first free entry */ for (i = 1; i < 256; i++) if (!(ad[i].fPresent)) break; if (i == 256) panic ("No free selector for TSS"); ad[i].uLimit0 = sizeof (ul_tss[mod_num]) - 1; ad[i].uLimit1 = 0; ad[i].pBase0 = (u32) pTSS & 0xFFFF; ad[i].pBase1 = ((u32) pTSS >> 16) & 0xFF; ad[i].pBase2 = (u32) pTSS >> 24; ad[i].uType = 0x09; /* 32-bit tss */ ad[i].uDPL = 0; /* Only let kernel perform task-switching */ ad[i].fPresent = 1; ad[i].f0 = 0; ad[i].fX = 0; ad[i].fGranularity = 0; /* Set granularity of tss in bytes */ pTSS->CR3 = (u32) pPageDirectory; pTSS->initial_EIP = (u32) pEntry; if (mod_num != 1) pTSS->EFLAGS = F_1 | F_IF | F_IOPL0; else pTSS->EFLAGS = F_1 | F_IF | F_IOPL; /* Give terminal server access to * screen memory */ pTSS->ESP = 0x400000 - 100; pTSS->EBP = 0x400000 - 100; semaphore_init (&pTSS->Msem, 1, 0); /* Return the index into the GDT for the segment */ return i << 3; }
void pca9555_target_init(void) { GPIO_PFCON &= ~(1<<2); /* PF2 for PCA9555 input INT */ pca9555_ports_init(); semaphore_init(&pca9555_sem, 1, 0); INTC_IMR |= IRQ_ARM_GPIO1; INTC_IECR |= IRQ_ARM_GPIO1; GPIO_ISF |= (1<<2); create_thread(pca9555_read_thread, pca9555_thread_stack, sizeof(pca9555_thread_stack), 0, "pca9555_read" IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU)); }
void lcd_remote_init_device(void) { /* reset */ remote_dev_enable(false); rc_status |= RC_FORCE_DETECT; /* force detection at startup */ /* unknown */ GPIO_SET_BITWISE(GPIOL_ENABLE, 0x80); GPIO_CLEAR_BITWISE(GPIOL_OUTPUT_VAL, 0x80); GPIO_SET_BITWISE(GPIOL_OUTPUT_EN, 0x80); /* a thread is required to poll & update the remote */ semaphore_init(&rc_thread_wakeup, 1, 0); remote_thread_id = create_thread(remote_thread, remote_stack, sizeof(remote_stack), 0, remote_thread_name IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU)); }
int dbg_read_memory(CH_DbgProgramState* state, CH_Address addr, uint32_t len, uint8_t* result, uint8_t* valid) { ExaminationClosure* cl = state->closure; CH_Range* range = safe_malloc(sizeof(CH_Range)); DbgReadMemoryClosure inner = { cl, result, valid, addr }; CH_Semaphore sem; range->start = addr; range->length = len; memset(valid, 0, len); semaphore_init(&sem); effect_map_reader_do_scan(get_builtin_write_map(), cl->query, 0, state->tstamp, range, 1, MODE_FIND_FIRST_COVER, -1, 0, read_memory_callback, &inner, &sem); semaphore_wait_for_all_removed(&sem); semaphore_destroy(&sem); return 1; }
e_int32 lm_init(laser_control_t *lc) { int ret; e_assert(!lm->state, E_ERROR_INVALID_STATUS); lm->state = STATE_PAUSE; lm->is_paused = 0; semaphore_init(&lm->wakeup, 0); lm->lc = lc; DMSG((STDOUT, "laser machine starting main routine...\r\n")); //启动sick数据读取线程 ret = createthread("laser_machine", (thread_func) &main_loop, lm, NULL, &lm->main_thread); e_assert(ret>0, ret); ret = resumethread(lm->main_thread); e_assert(ret>0, ret); return E_OK; }
void usb_init_device(void) { unsigned int i; for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++) semaphore_init(&endpoints[i].complete, 1, 0); /* Power up the core clocks to allow writing to some registers needed to power it down */ PCGCCTL = 0; #if CONFIG_CPU==S5L8701 PWRCON &= ~0x4000; PWRCONEXT &= ~0x800; INTMSK |= INTMSK_USB_OTG; #elif CONFIG_CPU==S5L8702 PWRCON(0) &= ~0x4; PWRCON(1) &= ~0x8; VIC0INTENABLE |= 1 << 19; #endif usb_drv_exit(); }
void imx233_dcp_init(void) { /* Reset block */ imx233_reset_block(&HW_DCP_CTRL); /* Setup contexte pointer */ HW_DCP_CONTEXT = (uint32_t)PHYSICAL_ADDR(&dcp_context); /* Enable context switching and caching */ __REG_SET(HW_DCP_CTRL) = HW_DCP_CTRL__ENABLE_CONTEXT_CACHING | HW_DCP_CTRL__ENABLE_CONTEXT_SWITCHING; /* Check that there are sufficiently many channels */ if(__XTRACT(HW_DCP_CAPABILITY0, NUM_CHANNELS) != HW_DCP_NUM_CHANNELS) panicf("DCP has %lu channels but was configured to use %d !", __XTRACT(HW_DCP_CAPABILITY0, NUM_CHANNELS), HW_DCP_NUM_CHANNELS); /* Setup channel arbiter to use */ arbiter_init(&channel_arbiter, HW_DCP_NUM_CHANNELS); /* Merge channel0 interrupt */ __REG_SET(HW_DCP_CHANNELCTRL) = HW_DCP_CHANNELCTRL__CH0_IRQ_MERGED; /* setup semaphores */ for(int i = 0; i< HW_DCP_NUM_CHANNELS; i++) semaphore_init(&channel_sema[i], 1, 0); }
void usb_drv_init(void) { for (unsigned i = 0; i < sizeof(endpoints)/(2*sizeof(struct ep_type)); i++) for (unsigned dir = 0; dir < 2; dir++) semaphore_init(&endpoints[i][dir].complete, 1, 0); /* Enable USB clock */ #if CONFIG_CPU==S5L8701 PWRCON &= ~0x4000; PWRCONEXT &= ~0x800; INTMSK |= INTMSK_USB_OTG; #elif CONFIG_CPU==S5L8702 PWRCON(0) &= ~0x4; PWRCON(1) &= ~0x8; VIC0INTENABLE |= 1 << 19; #endif PCGCCTL = 0; /* reset the beast */ usb_reset(); }
//如果不存在,创建,存在直接打开 // //./a.out ./ int main(int argc,char *argv[]) { char *shm_addr = NULL; int shmid = 0; int semid = 0; if( -1 == semaphore_init( &semid, argv[1], NSEMS) ) { perror("Failed to semaphore_init"); return -1; } if( -1 == shm_init( &shmid, &shm_addr, argv[1], SIZE, 0666) ) { perror("Failed to shm_init"); return -1; } while(1) { P(semid,WRITERS); printf(">"); fgets(shm_addr,1024,stdin); shm_addr[strlen(shm_addr) - 1] = '\0'; if( 0 == strncmp(shm_addr,"quit",4) ) { shm_del(&shmid, shm_addr); break; } V(semid,READRS); } exit(EXIT_SUCCESS); }
void Init() { int i = 0; int ret; semaphore_init(); ACoreOs_task_wake_after(3000); //scanf("%d",&delay_time); delay_time = 10; printk_spinLock("delay_time = %d\n",delay_time); for(i = 0; i < LES_TASKNUMS; i ++){ ret = ACoreOs_task_create_smp( task_nams[i], 20,&task_stack[i][0], ACOREOS_MINIMUM_STACK_SIZE*4, ACOREOS_PREEMPT | ACOREOS_TIMESLICE,NULL, &task_id[i], i%2+1); printk_spinLock("task id = 0x%x \n",task_id[i]); ret = ACoreOs_task_start( task_id[i], (ACoreOs_task_entry)task_entry[i], g_msg[i]); if(ret) printk_spinLock("start task%d failed\n",i); } CREATE_MONITOR(); }
/* * This function initializes shared variables of the fsal. */ fsal_status_t fsal_internal_init_global(fsal_init_info_t * fsal_info, fs_common_initinfo_t * fs_common_info) { /* sanity check */ if(!fsal_info || !fs_common_info) ReturnCode(ERR_FSAL_FAULT, 0); /* inits FS call semaphore */ if(fsal_info->max_fs_calls > 0) { int rc; limit_calls = TRUE; rc = semaphore_init(&sem_fs_calls, fsal_info->max_fs_calls); if(rc != 0) ReturnCode(ERR_FSAL_SERVERFAULT, rc); LogDebug(COMPONENT_FSAL, "FSAL INIT: Max simultaneous calls to filesystem is limited to %u.", fsal_info->max_fs_calls); } else { LogDebug(COMPONENT_FSAL, "FSAL INIT: Max simultaneous calls to filesystem is unlimited."); } /* setting default values. */ global_fs_info = default_hpss_info; /* Analyzing fs_common_info struct */ if((fs_common_info->behaviors.maxfilesize != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.maxlink != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.maxnamelen != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.maxpathlen != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.no_trunc != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.case_insensitive != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.case_preserving != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.named_attr != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.lease_time != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.supported_attrs != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.homogenous != FSAL_INIT_FS_DEFAULT)) ReturnCode(ERR_FSAL_NOTSUPP, 0); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, symlink_support); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, link_support); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support_owner); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support_async_block); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, cansettime); SET_INTEGER_PARAM(global_fs_info, fs_common_info, maxread); SET_INTEGER_PARAM(global_fs_info, fs_common_info, maxwrite); SET_BITMAP_PARAM(global_fs_info, fs_common_info, umask); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, auth_exportpath_xdev); SET_BITMAP_PARAM(global_fs_info, fs_common_info, xattr_access_rights); LogDebug(COMPONENT_FSAL, "FileSystem info :"); LogDebug(COMPONENT_FSAL, " maxfilesize = %llX ", global_fs_info.maxfilesize); LogDebug(COMPONENT_FSAL, " maxlink = %lu ", global_fs_info.maxlink); LogDebug(COMPONENT_FSAL, " maxnamelen = %lu ", global_fs_info.maxnamelen); LogDebug(COMPONENT_FSAL, " maxpathlen = %lu ", global_fs_info.maxpathlen); LogDebug(COMPONENT_FSAL, " no_trunc = %d ", global_fs_info.no_trunc); LogDebug(COMPONENT_FSAL, " chown_restricted = %d ", global_fs_info.chown_restricted); LogDebug(COMPONENT_FSAL, " case_insensitive = %d ", global_fs_info.case_insensitive); LogDebug(COMPONENT_FSAL, " case_preserving = %d ", global_fs_info.case_preserving); LogDebug(COMPONENT_FSAL, " fh_expire_type = %hu ", global_fs_info.fh_expire_type); LogDebug(COMPONENT_FSAL, " link_support = %d ", global_fs_info.link_support); LogDebug(COMPONENT_FSAL, " symlink_support = %d ", global_fs_info.symlink_support); LogDebug(COMPONENT_FSAL, " lock_support = %d ", global_fs_info.lock_support); LogDebug(COMPONENT_FSAL, " lock_support_owner = %d ", global_fs_info.lock_support_owner); LogDebug(COMPONENT_FSAL, " lock_support_async_block = %d ", global_fs_info.lock_support_async_block); LogDebug(COMPONENT_FSAL, " named_attr = %d ", global_fs_info.named_attr); LogDebug(COMPONENT_FSAL, " unique_handles = %d ", global_fs_info.unique_handles); LogDebug(COMPONENT_FSAL, " lease_time = %u.%u ", global_fs_info.lease_time.seconds, global_fs_info.lease_time.nseconds); LogDebug(COMPONENT_FSAL, " acl_support = %hu ", global_fs_info.acl_support); LogDebug(COMPONENT_FSAL, " cansettime = %d ", global_fs_info.cansettime); LogDebug(COMPONENT_FSAL, " homogenous = %d ", global_fs_info.homogenous); LogDebug(COMPONENT_FSAL, " supported_attrs = %llX ", global_fs_info.supported_attrs); LogDebug(COMPONENT_FSAL, " maxread = %llX ", global_fs_info.maxread); LogDebug(COMPONENT_FSAL, " maxwrite = %llX ", global_fs_info.maxwrite); LogDebug(COMPONENT_FSAL, " umask = %#o ", global_fs_info.umask); LogDebug(COMPONENT_FSAL, " auth_exportpath_xdev = %d ", global_fs_info.auth_exportpath_xdev); LogDebug(COMPONENT_FSAL, " xattr_access_rights = %#o ", global_fs_info.xattr_access_rights); ReturnCode(ERR_FSAL_NO_ERROR, 0); }
semaphore_wrapper(int initialCount) { semaphore_init(&m_sem, initialCount); }
void semaphore_reset(t_semaphore *semaphore) { semaphore_init(semaphore, 0); }
/* * probe function for new CPC-USB devices */ static int cpcusb_probe(struct usb_interface *interface, const struct usb_device_id *id) { CPC_USB_T *card = NULL; CPC_CHAN_T *chan = NULL; struct usb_device *udev = interface_to_usbdev(interface); struct usb_host_interface *iface_desc; struct usb_endpoint_descriptor *endpoint; int i, j, retval = -ENOMEM, slot; slot = cpcusb_get_free_slot(); if (slot < 0) { info("No more devices supported"); return -ENOMEM; } /* allocate memory for our device state and initialize it */ card = kzalloc(sizeof(CPC_USB_T), GFP_KERNEL); if (!card) { err("Out of memory"); return -ENOMEM; } CPCUSB_Table[slot] = card; /* allocate and initialize the channel struct */ card->chan = kmalloc(sizeof(CPC_CHAN_T), GFP_KERNEL); if (!card->chan) { kfree(card); err("Out of memory"); return -ENOMEM; } chan = card->chan; memset(chan, 0, sizeof(CPC_CHAN_T)); ResetBuffer(chan); semaphore_init(&card->sem); spin_lock_init(&card->slock); card->udev = udev; card->interface = interface; if (udev->descriptor.iSerialNumber) { usb_string(udev, udev->descriptor.iSerialNumber, card->serialNumber, 128); info("Serial %s", card->serialNumber); } card->productId = udev->descriptor.idProduct; info("Product %s", card->productId == USB_CPCUSB_LPC2119_PRODUCT_ID ? "CPC-USB/ARM7" : "CPC-USB/M16C"); /* set up the endpoint information */ /* check out the endpoints */ /* use only the first bulk-in and bulk-out endpoints */ iface_desc = &interface->altsetting[0]; for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { endpoint = &iface_desc->endpoint[i].desc; if (!card->num_intr_in && (endpoint->bEndpointAddress & USB_DIR_IN) && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) { card->intr_in_urb = usb_alloc_urb(0, GFP_KERNEL); card->num_intr_in = 1; if (!card->intr_in_urb) { err("No free urbs available"); goto error; } dbg("intr_in urb %d", card->num_intr_in); } if (!card->num_bulk_in && (endpoint->bEndpointAddress & USB_DIR_IN) && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)) { card->num_bulk_in = 2; for (j = 0; j < CPC_USB_URB_CNT; j++) { card->urbs[j].size = endpoint->wMaxPacketSize; card->urbs[j].urb = usb_alloc_urb(0, GFP_KERNEL); if (!card->urbs[j].urb) { err("No free urbs available"); goto error; } card->urbs[j].buffer = usb_buffer_alloc(udev, card->urbs[j].size, GFP_KERNEL, &card->urbs[j].urb->transfer_dma); if (!card->urbs[j].buffer) { err("Couldn't allocate bulk_in_buffer"); goto error; } } info("%s - %d reading URB's allocated", __func__, CPC_USB_URB_CNT); } if (!card->num_bulk_out && !(endpoint->bEndpointAddress & USB_DIR_IN) && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)) { card->num_bulk_out = 2; for (j = 0; j < CPC_USB_URB_CNT; j++) { card->wrUrbs[j].size = endpoint->wMaxPacketSize; card->wrUrbs[j].urb = usb_alloc_urb(0, GFP_KERNEL); if (!card->wrUrbs[j].urb) { err("No free urbs available"); goto error; } card->wrUrbs[j].buffer = usb_buffer_alloc(udev, card->wrUrbs[j].size, GFP_KERNEL, &card->wrUrbs[j].urb->transfer_dma); if (!card->wrUrbs[j].buffer) { err("Couldn't allocate bulk_out_buffer"); goto error; } usb_fill_bulk_urb(card->wrUrbs[j].urb, udev, usb_sndbulkpipe(udev, endpoint->bEndpointAddress), card->wrUrbs[j].buffer, card->wrUrbs[j].size, cpcusb_write_bulk_callback, card); } info("%s - %d writing URB's allocated", __func__, CPC_USB_URB_CNT); } } if (!(card->num_bulk_in && card->num_bulk_out)) { err("Couldn't find both bulk-in and bulk-out endpoints"); goto error; } /* allow device read, write and ioctl */ card->present = 1; /* we can register the device now, as it is ready */ usb_set_intfdata(interface, card); retval = usb_register_dev(interface, &cpcusb_class); if (retval) { /* something prevented us from registering this driver */ err("Not able to get a minor for this device."); usb_set_intfdata(interface, NULL); goto error; } card->chan->minor = card->minor = interface->minor; chan->buf = vmalloc(sizeof(CPC_MSG_T) * CPC_MSG_BUF_CNT); if (chan->buf == NULL) { err("Out of memory"); retval = -ENOMEM; goto error; } info("Allocated memory for %d messages (%lu kbytes)", CPC_MSG_BUF_CNT, (long unsigned int)(sizeof(CPC_MSG_T) * CPC_MSG_BUF_CNT) / 1000); memset(chan->buf, 0, sizeof(CPC_MSG_T) * CPC_MSG_BUF_CNT); ResetBuffer(chan); card->chan->CPCWait_q = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL); if (!card->chan->CPCWait_q) { err("Out of memory"); retval = -ENOMEM; goto error; } init_waitqueue_head(card->chan->CPCWait_q); CPCUSB_Table[slot] = card; card->idx = slot; CPCUsbCnt++; /* let the user know what node this device is now attached to */ info("Device now attached to USB-%d", card->minor); return 0; error: for (j = 0; j < CPC_USB_URB_CNT; j++) { if (card->urbs[j].buffer) { usb_buffer_free(card->udev, card->urbs[j].size, card->urbs[j].buffer, card->urbs[j].urb->transfer_dma); card->urbs[j].buffer = NULL; } if (card->urbs[j].urb) { usb_free_urb(card->urbs[j].urb); card->urbs[j].urb = NULL; } } cpcusb_delete(card); return retval; }
/* * This function initializes shared variables of the fsal. */ fsal_status_t fsal_internal_init_global(fsal_init_info_t * fsal_info, fs_common_initinfo_t * fs_common_info) { /* sanity check */ if(!fsal_info || !fs_common_info) ReturnCode(ERR_FSAL_FAULT, 0); /* inits FS call semaphore */ if(fsal_info->max_fs_calls > 0) { int rc; limit_calls = TRUE; rc = semaphore_init(&sem_fs_calls, fsal_info->max_fs_calls); if(rc != 0) ReturnCode(ERR_FSAL_SERVERFAULT, rc); LogDebug(COMPONENT_FSAL, "FSAL INIT: Max simultaneous calls to filesystem is limited to %u.", fsal_info->max_fs_calls); } else { LogDebug(COMPONENT_FSAL "FSAL INIT: Max simultaneous calls to filesystem is unlimited."); } /* setting default values. */ global_fs_info = default_hpss_info; /* Analyzing fs_common_info struct */ if((fs_common_info->behaviors.maxfilesize != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.maxlink != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.maxnamelen != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.maxpathlen != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.no_trunc != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.case_insensitive != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.case_preserving != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.named_attr != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.lease_time != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.supported_attrs != FSAL_INIT_FS_DEFAULT) || (fs_common_info->behaviors.homogenous != FSAL_INIT_FS_DEFAULT)) ReturnCode(ERR_FSAL_NOTSUPP, 0); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, symlink_support); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, link_support); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support_owner); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support_async_block); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, cansettime); SET_INTEGER_PARAM(global_fs_info, fs_common_info, maxread); SET_INTEGER_PARAM(global_fs_info, fs_common_info, maxwrite); SET_BITMAP_PARAM(global_fs_info, fs_common_info, umask); SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, auth_exportpath_xdev); SET_BITMAP_PARAM(global_fs_info, fs_common_info, xattr_access_rights); display_fsinfo(&global_fs_info); ReturnCode(ERR_FSAL_NO_ERROR, 0); }
posix_semaphore(unsigned int initialCount) { semaphore_init(&m_sem, initialCount); }
void KERNEL_CALL semaphores_install(void) { memsetd(gSemaphores, 0, NUM_SEMAPHORES); semaphore_init(KEYBOARD_SEMAPHORE, 1); }
semaphore_wrapper(unsigned int initialCount) { semaphore_init(&m_sem, initialCount); }
void init(void) { TID_t startup_thread; int numcpus; /* Initialize polling TTY driver for kprintf() usage. */ polltty_init(); kwrite("BUENOS is a University Educational Nutshell Operating System\n"); kwrite("==========================================================\n"); kwrite("\n"); kwrite("Copyright (C) 2003-2006 Juha Aatrokoski, Timo Lilja,\n"); kwrite(" Leena Salmela, Teemu Takanen, Aleksi Virtanen\n"); kwrite("See the file COPYING for licensing details.\n"); kwrite("\n"); kwrite("Initializing memory allocation system\n"); kmalloc_init(); kwrite("Reading boot arguments\n"); bootargs_init(); /* Seed the random number generator. */ if (bootargs_get("randomseed") == NULL) { _set_rand_seed(0); } else { int seed = atoi(bootargs_get("randomseed")); kprintf("Seeding pseudorandom number generator with %i\n", seed); _set_rand_seed(seed); } numcpus = cpustatus_count(); kprintf("Detected %i CPUs\n", numcpus); KERNEL_ASSERT(numcpus <= CONFIG_MAX_CPUS); kwrite("Initializing interrupt handling\n"); interrupt_init(numcpus); kwrite("Initializing threading system\n"); thread_table_init(); kwrite("Initializing user process system\n"); process_init(); kwrite("Initializing sleep queue\n"); sleepq_init(); kwrite("Initializing semaphores\n"); semaphore_init(); kwrite("Initializing device drivers\n"); device_init(); kprintf("Initializing virtual filesystem\n"); vfs_init(); kwrite("Initializing scheduler\n"); scheduler_init(); kwrite("Initializing virtual memory\n"); vm_init(); kprintf("Creating initialization thread\n"); startup_thread = thread_create(&init_startup_thread, 0); thread_run(startup_thread); kprintf("Starting threading system and SMP\n"); /* Let other CPUs run */ kernel_bootstrap_finished = 1; _interrupt_clear_bootstrap(); _interrupt_enable(); /* Enter context switch, scheduler will be run automatically, since thread_switch() behaviour is identical to timer tick (thread timeslice is over). */ thread_switch(); /* We should never get here */ KERNEL_PANIC("Threading system startup failed."); }
void lock_init(Lock *lock) { semaphore_init(&lock->sema, 1); }
int jpege_main(void *Param) { OMX_PARAM_PORTDEFINITIONTYPE asPortDefinition[2]; OMX_PORT_PARAM_TYPE sImageInit; OMX_IMAGE_PARAM_PORTFORMATTYPE sImageParamPortformatType; OMX_CALLBACKTYPE sCallbacks; OMX_IMAGE_PARAM_QFACTORTYPE sImageParamQFacttype; int i = 0, j = 0; OMX_ERRORTYPE err = OMX_ErrorNone; OMX_STATETYPE state = OMX_StateMax; OMX_U32 nQFactor = 0; OMX_S8 **cName; OMX_U32 numComp; char ConfigFileName[256]; OMX_S8 componentName[256]; OMX_VERSIONTYPE componentVer; OMX_VERSIONTYPE specVer; OMX_UUIDTYPE componentUUID; void *InputPortRet, *OutputPortRet, *OutputDataRet; memset(asPortDefinition, 0, sizeof(asPortDefinition)); memset(&sImageInit, 0, sizeof(sImageInit)); memset(&sImageParamPortformatType, 0, sizeof(sImageParamPortformatType)); memset(&sCallbacks, 0, sizeof(sCallbacks)); output_mode = ((VIDEODECFUNCPARAMTYPE *) Param)->Mode; nFrameWidth = ((VIDEODECFUNCPARAMTYPE *) Param)->nFrameWidth; nFrameHeight = ((VIDEODECFUNCPARAMTYPE *) Param)->nFrameHeight; eColorFormat = ((VIDEODECFUNCPARAMTYPE *) Param)->eColorFormat; nQFactor = ((VIDEODECFUNCPARAMTYPE *) Param)->nQFactor; int ret = 0, hasHandle = 0, commandValue = 0, hasNoWait = 1; /* */ ef = ff = 0; if ((frameSize = yuv_framesize(nFrameWidth, nFrameHeight, eColorFormat)) <= 0) { FILE_DBG1("[emxx_jpeglib][%d] yuv_init\n", __LINE__); return -1; } strcpy(ConfigFileName, AV_CODEC_CONFIG_FILE_NAME); err = OMF_SetLogMode(0x00000001); if (err != OMX_ErrorNone) { FILE_DBG1("[emxx_jpeglib] Can't set log mode! error code = 0x%08x\n", err); goto jpege_end; } err = OMF_SetConfiguration(ConfigFileName); if (err != OMX_ErrorNone) { FILE_DBG1("[emxx_jpeglib] Can't set configuration file! error code = 0x%08x\n", err); goto jpege_end; } err = OMX_Init(); if (err != OMX_ErrorNone) { FILE_DBG("can't initialize OMX LIb, exit\n"); goto jpege_end; } /* Get MC Name */ cName = (OMX_U8 **) malloc(sizeof(OMX_U8 *)); cName[0] = (OMX_U8 *) malloc(128 * sizeof(OMX_U8)); numComp = 1; err = OMX_GetComponentsOfRole(JPEGE_ROLE, &numComp, cName); if (err != OMX_ErrorNone) { FILE_DBG1("[emxx_jpeglib] Can't get component name! error code = 0x%8x\n", err); } else { FILE_DBG1("OMF Name = %s\n", cName[0]); } /* Get Media Component handle. */ sCallbacks.EventHandler = event_handler; sCallbacks.EmptyBufferDone = empty_buffer_done; sCallbacks.FillBufferDone = fill_buffer_done; err = OMX_GetHandle(&Video_hComponent, cName[0], NULL, &sCallbacks); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't get handle! erro code = 0x%08x\n", __LINE__, err); free(cName[0]); free(cName); ret = -1; goto jpege_end; } hasHandle = 1; free(cName[0]); free(cName); /* GetComponentVersion */ err = OMX_GetComponentVersion(Video_hComponent, componentName, &componentVer, &specVer, &componentUUID); if (err != OMX_ErrorNone) { FILE_DBG2( "[emxx_jpeglib][%d] Can't get component version! error code = 0x%08x\n", __LINE__, err); return -1; } else { printf("Component Version = 0x%08x\n", componentVer); printf("Spec Version = 0x%08x\n", specVer); } /* Get OMX_IndexParamImageInit. */ sImageInit.nSize = sizeof(OMX_PORT_PARAM_TYPE); err = OMX_GetParameter(Video_hComponent, OMX_IndexParamImageInit, &sImageInit); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't get parameter! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } /* Get & Set OMX_IndexParamPortDefinition. */ for (i = 0; i < sImageInit.nPorts; i++) { asPortDefinition[i].nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE); asPortDefinition[i].nPortIndex = sImageInit.nStartPortNumber + i; err = OMX_GetParameter(Video_hComponent, OMX_IndexParamPortDefinition, &asPortDefinition[i]); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't get parameter! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } if (i == PORT_OFFSET_INPUT) /* VPB+0 */ { asPortDefinition[PORT_OFFSET_INPUT].format.image.nFrameWidth = nFrameWidth; asPortDefinition[PORT_OFFSET_INPUT].format.image.nFrameHeight = nFrameHeight; asPortDefinition[PORT_OFFSET_INPUT].format.image.eColorFormat = eColorFormat; err = OMX_SetParameter(Video_hComponent, OMX_IndexParamPortDefinition, &asPortDefinition[PORT_OFFSET_INPUT]); if (err != OMX_ErrorNone) { extern int end_flag; printf( "[emxx_jpeglib][%d] Can't set parameter! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } } } nVideoPortIndex[PORT_OFFSET_INPUT] = asPortDefinition[PORT_OFFSET_INPUT].nPortIndex; nVideoPortIndex[PORT_OFFSET_OUTPUT] = asPortDefinition[PORT_OFFSET_OUTPUT].nPortIndex; VideoInputBuffNum = asPortDefinition[PORT_OFFSET_INPUT].nBufferCountActual; VideoOutputBuffNum = asPortDefinition[PORT_OFFSET_OUTPUT].nBufferCountActual; printf("VideoInputBuffNum, %d VideoOutputBuffNum, %d\n", VideoInputBuffNum, VideoOutputBuffNum); /* Get & Set OMX_IndexParamImagePortFormat. */ sImageParamPortformatType.nSize = sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE); sImageParamPortformatType.nPortIndex = PORT_OFFSET_INPUT; sImageParamPortformatType.nIndex = nVideoPortIndex[PORT_OFFSET_INPUT]; err = OMX_GetParameter(Video_hComponent, OMX_IndexParamImagePortFormat, &sImageParamPortformatType); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't get parameter! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } sImageParamPortformatType.nSize = sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE); sImageParamPortformatType.eColorFormat = eColorFormat; err = OMX_SetParameter(Video_hComponent, OMX_IndexParamImagePortFormat, &sImageParamPortformatType); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't get parameter! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } /* Change state to OMX_StateIdle from OMX_StateLoaded. */ pthread_mutex_lock(&VideoMutex); err = OMX_SendCommand(Video_hComponent, OMX_CommandStateSet, OMX_StateIdle, NULL); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't send command! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } /* Allocate stream buffer. */ for (i = 0; i < sImageInit.nPorts; i++) { for (j = 0; j < asPortDefinition[i].nBufferCountActual; j++) { err = OMX_AllocateBuffer(Video_hComponent, &apsVideoBuffer[i][j], asPortDefinition[i].nPortIndex, NULL, asPortDefinition[i].nBufferSize); if (err != OMX_ErrorNone) { FILE_DBG2( "[emxx_jpeglib][%d] Can't allocate buffer! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } FILE_DBG2("[%d][%d] allocated\n", i, j); } } /* Complete state transition. */ pthread_cond_wait(&VideoCond, &VideoMutex); pthread_mutex_unlock(&VideoMutex); semaphore_init(CODEC_VIDEO, output_mode); #if 1 /* Create data input thread. */ if (pthread_create(&VideoInputThreadId, NULL, (void*) jpeg_input_port_thread, NULL) != 0) { FILE_DBG1("[emxx_jpeglib][%d] failed pthread_create input_port_thread\n", __LINE__); ret = -1; goto jpege_end; } /* Create data output thread. */ if (pthread_create(&VideoOutputThreadId, NULL, (void*) jpeg_output_port_thread, NULL) != 0) { FILE_DBG1("[emxx_jpeglib][%d] failed output_port_thread\n", __LINE__); ret = -1; goto jpege_end; } /* Create data output thread */ if (pthread_create(&VideoOutputDataThreadId, NULL, (void*) jpeg_output_data_thread, NULL) != 0) { FILE_DBG1("[emxx_jpeglib][%d] pthread_create output_data_thread\n", __LINE__); ret = -1; goto jpege_end; } #endif /* Change state to OMX_StateExecuting form OMX_StateIdle. */ pthread_mutex_lock(&VideoMutex); err = OMX_SendCommand(Video_hComponent, OMX_CommandStateSet, OMX_StateExecuting, NULL); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't send command! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } /* Complete state transition. */ pthread_cond_wait(&VideoCond, &VideoMutex); pthread_mutex_unlock(&VideoMutex); FILE_DBG("state has been changed to executing\n"); VideoOutputPortThreadLoopFlag = 1; while (!ef || !ff) { printf("."); } FILE_DBG("start close OMX\n"); hasNoWait = 0; VideoOutputPortThreadLoopFlag = 0; pthread_mutex_lock(&VideoMutex); err = OMX_SendCommand(Video_hComponent, OMX_CommandStateSet, OMX_StateIdle, NULL); if (err != OMX_ErrorNone) { FILE_DBG("can't send command\n"); ret = -1; goto jpege_end; } pthread_cond_wait(&VideoCond, &VideoMutex); pthread_mutex_unlock(&VideoMutex); /* Change state to OMX_StateLoaded from OMX_StateIdle. */ pthread_mutex_lock(&VideoMutex); err = OMX_SendCommand(Video_hComponent, OMX_CommandStateSet,OMX_StateLoaded, NULL); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't send command! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } FILE_DBG("changed to loaded state\n"); /* Free buffer. */ for (i = 0; i < sImageInit.nPorts; i++) { for (j = 0; j < asPortDefinition[i].nBufferCountActual; j++) { err = OMX_FreeBuffer(Video_hComponent, asPortDefinition[i].nPortIndex, apsVideoBuffer[i][j]); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't free buffer! erro code = 0x%08x\n", __LINE__, err); ret = -1; goto jpege_end; } } } /* Complete state transition. */ pthread_cond_wait(&VideoCond, &VideoMutex); pthread_mutex_unlock(&VideoMutex); jpege_end: FILE_DBG("free buffer\n"); /* Free JPEG Media Component handle. */ if (hasHandle) { err = OMX_FreeHandle(Video_hComponent); if (err != OMX_ErrorNone) { FILE_DBG2("[emxx_jpeglib][%d] Can't free handle! erro code = 0x%08x\n", __LINE__, err); ret = -1; } } semaphore_deinit(CODEC_VIDEO, output_mode); FILE_DBG("close debug file"); FILE_DBG_CLOSE(); return 0; }
void init(void) { TID_t startup_thread; int numcpus; /* Initialise Static Allocation */ stalloc_init(); /* Initialize polling TTY driver for kprintf() usage. */ polltty_init(); kwrite("Kudos is an educational operating system by the University of Copenhagen\n"); kwrite("========================================================================\n"); kwrite("Based on the Buenos operating system skeleton\n"); kwrite("\n"); kprintf("Copyright (C) 2003-2016 Juha Aatrokoski, Timo Lilja,\n"); kprintf(" Leena Salmela, Teemu Takanen, Aleksi Virtanen, Philip Meulengracht,\n"); kprintf(" Troels Henriksen, Annie Jane Pinder, Niels Gustav Westphal Serup,\n"); kprintf(" Nicklas Warming Jacobsen, Oleksandr Shturmov.\n"); kwrite("See the file COPYING for licensing details.\n"); kwrite("\n"); kwrite("Reading boot arguments\n"); bootargs_init((void*)BOOT_ARGUMENT_AREA); /* Seed the random number generator. */ if (bootargs_get("randomseed") == NULL) { _set_rand_seed(0); } else { int seed = atoi(bootargs_get("randomseed")); kprintf("Seeding pseudorandom number generator with %i\n", seed); _set_rand_seed(seed); } numcpus = cpustatus_count(); kprintf("Detected %i CPUs\n", numcpus); KERNEL_ASSERT(numcpus <= CONFIG_MAX_CPUS); kwrite("Initializing interrupt handling\n"); interrupt_init(numcpus); kwrite("Initializing threading system\n"); thread_table_init(); kwrite("Initializing sleep queue\n"); sleepq_init(); kwrite("Initializing semaphores\n"); semaphore_init(); kwrite("Initializing device drivers\n"); device_init(); kprintf("Initializing virtual filesystem\n"); vfs_init(); kwrite("Initializing scheduler\n"); scheduler_init(); kwrite("Initializing virtual memory\n"); vm_init(); kprintf("Creating initialization thread\n"); startup_thread = thread_create(&init_startup_thread, 0); thread_run(startup_thread); kprintf("Starting threading system and SMP\n"); /* Let other CPUs run */ kernel_bootstrap_finished = 1; _interrupt_clear_bootstrap(); _interrupt_enable(); /* Enter context switch, scheduler will be run automatically, since thread_switch() behaviour is identical to timer tick (thread timeslice is over). */ thread_switch(); /* We should never get here */ KERNEL_PANIC("Threading system startup failed."); }
void usb_drv_init(void) { logf("usb_drv_init() !!!!\n"); if (!initialized) { int i; for (i = 0; i < USB_NUM_EPS; i++) { semaphore_init(&endpoints[i][0].complete, 1, 0); semaphore_init(&endpoints[i][1].complete, 1, 0); } initialized = true; } usb_enable_pll(); /* we have external power, so boost cpu */ cpu_boost(1); /* length regulator: normal operation */ ascodec_write(AS3514_CVDD_DCDC3, ascodec_read(AS3514_CVDD_DCDC3) | 1<<2); /* AHB part */ bitset32(&CGU_PERI, CGU_USB_CLOCK_ENABLE); /* reset AHB */ CCU_SRC = CCU_SRC_USB_AHB_EN; CCU_SRL = CCU_SRL_MAGIC_NUMBER; mdelay(1); CCU_SRC = CCU_SRL = 0; USB_GPIO_CSR = USB_GPIO_TX_ENABLE_N | USB_GPIO_TX_BIT_STUFF_EN | USB_GPIO_XO_ON | USB_GPIO_CLK_SEL10; /* 0x06180000; */ /* bug workaround according to linux patch */ USB_DEV_CFG = (USB_DEV_CFG & ~3) | 1; /* full speed */ /* enable soft disconnect */ USB_DEV_CTRL |= USB_DEV_CTRL_SOFT_DISCONN; usb_phy_on(); usb_phy_suspend(); USB_DEV_CTRL |= USB_DEV_CTRL_SOFT_DISCONN; /* We don't care about SVC or SOF events */ /* Right now we don't handle suspend, so mask those too */ USB_DEV_INTR_MASK = USB_DEV_INTR_SVC | USB_DEV_INTR_SOF | USB_DEV_INTR_USB_SUSPEND | USB_DEV_INTR_EARLY_SUSPEND; USB_DEV_CFG = USB_DEV_CFG_STAT_ACK | USB_DEV_CFG_UNI_DIR | USB_DEV_CFG_PI_16BIT | USB_DEV_CFG_HS | USB_DEV_CFG_SELF_POWERED | USB_DEV_CFG_CSR_PRG | USB_DEV_CFG_PHY_ERR_DETECT; USB_DEV_CTRL = USB_DEV_CTRL_DESC_UPDATE | USB_DEV_CTRL_THRES_ENABLE | USB_DEV_CTRL_BURST_ENABLE | USB_DEV_CTRL_BLEN_8DWORDS | USB_DEV_CTRL_TLEN_8THMAXSIZE; USB_DEV_EP_INTR_MASK &= ~((1<<0) | (1<<16)); /* ep 0 */ reset_endpoints(1); /* clear pending interrupts */ USB_DEV_EP_INTR = 0xffffffff; USB_DEV_INTR = 0xffffffff; VIC_INT_ENABLE = INTERRUPT_USB; usb_phy_resume(); USB_DEV_CTRL &= ~USB_DEV_CTRL_SOFT_DISCONN; USB_GPIO_CSR = USB_GPIO_TX_ENABLE_N | USB_GPIO_TX_BIT_STUFF_EN | USB_GPIO_XO_ON | USB_GPIO_HS_INTR | USB_GPIO_CLK_SEL10; /* 0x06180000; */ tick_add_task(usb_tick); usb_enum_timeout = HZ; /* one second timeout for enumeration */ }
/* one time init (once per connection) - basicaly enable usb core */ void usb_drv_init(void) { int ep_num; /* enable USB clock */ SCU_CLKCFG &= ~(1<<6); /* 1. do soft disconnect */ DEV_CTL = (1<<3); /* DEV_SELF_PWR */ /* 2. do power on reset to PHY */ DEV_CTL = (1<<3) | /* DEV_SELF_PWR */ (1<<7); /* SOFT_POR */ /* 3. wait more than 10ms */ udelay(20000); /* 4. clear SOFT_POR bit */ DEV_CTL &= ~(1<<7); /* 5. configure minimal EN_INT */ EN_INT = (1<<6) | /* Enable Suspend Interrupt */ (1<<5) | /* Enable Resume Interrupt */ (1<<4) | /* Enable USB Reset Interrupt */ (1<<3) | /* Enable OUT Token receive Interrupt EP0 */ (1<<2) | /* Enable IN Token transmits Interrupt EP0 */ (1<<1); /* Enable SETUP Packet Receive Interrupt */ /* 6. configure INTCON */ INTCON = (1<<2) | /* interrupt high active */ (1<<0); /* enable EP0 interrupts */ /* 7. configure EP0 control registers */ TX0CON = (1<<6) | /* Set as one to enable the EP0 tx irq */ (1<<2); /* Set as one to response NAK handshake */ RX0CON = (1<<7) | (1<<4) | /* Endpoint 0 Enable. When cleared the endpoint does * not respond to an SETUP or OUT token */ (1<<3); /* Set as one to response NAK handshake */ /* 8. write final bits to DEV_CTL */ DEV_CTL = (1<<8) | /* Configure CSR done */ (1<<6) | /* 16-bit data path enabled. udc_clk = 30MHz */ (1<<4) | /* Device soft connect */ (1<<3); /* Device self power */ /* init semaphore of ep0 */ semaphore_init(&ctrlep[DIR_OUT].complete, 1, 0); semaphore_init(&ctrlep[DIR_IN].complete, 1, 0); for (ep_num = 1; ep_num < USB_NUM_ENDPOINTS; ep_num++) { semaphore_init(&endpoints[ep_num].complete, 1, 0); if (ep_num%3 == 0) /* IIN 3, 6, 9, 12, 15 */ { IIN_TXCON(ep_num) |= (ep_num<<8)|(1<<3)|(1<<2); /* ep_num, enable, NAK */ } else if (ep_num%3 == 1) /* BOUT 1, 4, 7, 10, 13 */ { BOUT_RXCON(ep_num) |= (ep_num<<8)|(1<<4)|(1<<3); /* ep_num, NAK, enable */ } else if (ep_num%3 == 2) /* BIN 2, 5, 8, 11, 14 */ { BIN_TXCON(ep_num) |= (ep_num<<8)|(1<<3)|(1<<2); /* ep_num, enable, NAK */ } } }
int main(void) { char decission[50]; int s, sem; packet* rec = malloc(sizeof (packet)); if(rec == NULL){ ERR("malloc"); } packet* tmp = malloc(sizeof (packet)); if(tmp == NULL){ ERR("malloc"); } char c; int x, y, points,i; int isAnyTileAvaliable; semaphore_init(&sem, 'E', 1); /* Set signals handlers */ if(sethandler(sigint_handler,SIGINT)) ERR("Setting SIGINT:"); if(sethandler(sigterm_handler,SIGTERM)) ERR("Setting SIGTERM:"); /********* TCP IP *********/ s = tcp_connect_socket("localhost", 2000); printf("##############################\n"); printf("## WELCOME TO SCRABBLE GAME ##\n"); printf("##############################\n"); while (g_doWork) { int t; if ((t = tcp_socket_read_packet(s, rec)) == 0 && g_doWork==1) { perror("Server closed connection client\n"); break; } else if (t < 0) { perror("recv"); break; } switch (rec->msg) { case NO_PLAYER: printf("Waiting for another player to connect...\n"); break; case PAIR_MATCH: printf("Player found - starting the game...\n"); break; case INFO: printf("Player found - starting the game...\n"); scrabble_game_print_title(); scrabble_game_print_board(rec->currentBoard); scrabble_game_print_wait_for_move(); break; case REQUEST_MOVE: /* Print points in the right order */ scrabble_game_print_title(); scrabble_game_print_points(rec->p1Points, rec->p2Points, rec->playerType); /* Print current board state */ scrabble_game_print_board(rec->currentBoard); /* Print available tiles */ printf("----------------------------------------\n "); scrabble_game_print_available_tiles(rec->tiles, 5); printf("----------------------------------------\n"); isAnyTileAvaliable = 0; for(i=0; i<5;i++){ if(rec->tiles[i] != 'x'){ isAnyTileAvaliable = 1; } } if(isAnyTileAvaliable == 1) { points = 0; if(-1 == gather_input(&c, &x, &y, &points, rec->tiles, rec->currentBoard)) { printf("gater input error\n"); }else { /* Print updated points */ scrabble_game_print_title(); if (rec->playerType == FIRST) rec->p1Points += points; if (rec->playerType == SECOND) rec->p2Points += points; scrabble_game_print_points(rec->p1Points, rec->p2Points, rec->playerType); /* Print updated board */ rec->currentBoard[x][y] = c; scrabble_game_print_board(rec->currentBoard); /* Send data to server. */ tmp->msg = MOVE_DATA; tmp->letter = c; tmp->x_coord = x; tmp->y_coord = y; tmp->p1Points = rec->p1Points; tmp->p2Points = rec->p2Points; tcp_socket_send_packet(s, tmp); scrabble_game_print_wait_for_move(); } } else{ printf("##########################################\n"); printf("## END OF MATCH ##\n"); printf("##########################################\n"); printf("Do you want to play another game?(Y/N)\n"); scanf(" %c", decission); printf("%s \n",decission); tmp->isMatchOngoing = -1; if (decission[0] == 'Y') { tmp->msg = PLAY_ANOTHER_GAME; tcp_socket_send_packet(s, tmp); } else { tmp->msg = FINISH_GAME; printf("isMatchOngoing = %d \n", tmp->isMatchOngoing); tcp_socket_send_packet(s, tmp); return EXIT_SUCCESS; } } break; case DISCONNECTED: printf("##########################################\n"); printf("## Connection lost! ##\n"); printf("##########################################\n"); printf("Sorry but connection with other player is\n"); printf("lost. Do you want to play another game?(Y/N)\n"); scanf(" %c", decission); printf("%s \n",decission); if (decission[0] == 'Y') { tmp->msg = PLAY_ANOTHER_GAME; tcp_socket_send_packet(s, tmp); } else { tmp->msg = FINISH_GAME; tcp_socket_send_packet(s, tmp); return EXIT_SUCCESS; } break; case EXIT: printf("Server disconnected.\n"); return EXIT_SUCCESS; default: printf("Cannot interpret packet's message: %d \n", rec->msg); } }; printf("Disconnected\n"); if(-1 == close(s)){ ERR("close"); } return 0; }
void drd_semaphore_init(const Addr semaphore, const Word pshared, const Word value) { semaphore_init(semaphore, pshared, value); }
void usb_drv_init(void) { for (int i = 0; i < USB_NUM_ENDPOINTS; i++) for (int dir = 0; dir < 2; dir++) semaphore_init(&endpoints[i][dir].complete, 1, 0); bitset32(&CGU_PERI, CGU_USB_CLOCK_ENABLE); CCU_USB = (CCU_USB & ~(3<<24)) | (1 << 24); /* ?? */ /* PHY clock */ CGU_USB = 1<<5 /* enable */ | 0 << 2 | 0; /* source = ? (24MHz crystal?) */ PCGCCTL = 0; DCTL = DCTL_pwronprgdone | DCTL_sftdiscon; GRSTCTL = GRSTCTL_csftrst; while (GRSTCTL & GRSTCTL_csftrst); /* Wait for OTG to ack reset */ while (!(GRSTCTL & GRSTCTL_ahbidle)); /* Wait for OTG AHB master idle */ GRXFSIZ = 512; GNPTXFSIZ = MAKE_FIFOSIZE_DATA(512); /* FIXME: the current code is for internal DMA only, the clip+ architecture * defines the internal DMA model */ GAHBCFG = (GAHBCFG_INT_DMA_BURST_INCR << GAHBCFG_hburstlen_bitp) | GAHBCFG_dma_enable | GAHBCFG_glblintrmsk; /* Select UTMI+ 16 */ GUSBCFG = GUSBCFG_force_device_mode | GUSBCFG_phy_if | 7 << GUSBCFG_toutcal_bitp; /* Do something that is probably CCU related but undocumented*/ CCU_USB |= 0x1000; CCU_USB &= ~0x300000; DCFG = DCFG_nzstsouthshk | DCFG_devspd_hs_phy_hs; /* Address 0, high speed */ DCTL = DCTL_pwronprgdone; /* Check hardware capabilities */ if(extract(GHWCFG2, arch) != GHWCFG2_ARCH_INTERNAL_DMA) panicf("usb-drv: wrong architecture (%ld)", extract(GHWCFG2, arch)); if(extract(GHWCFG2, hs_phy_type) != GHWCFG2_PHY_TYPE_UTMI) panicf("usb-drv: wrong HS phy type (%ld)", extract(GHWCFG2, hs_phy_type)); if(extract(GHWCFG2, fs_phy_type) != GHWCFG2_PHY_TYPE_UNSUPPORTED) panicf("usb-drv: wrong FS phy type (%ld)", extract(GHWCFG2, fs_phy_type)); if(extract(GHWCFG4, utmi_phy_data_width) != 0x2) panicf("usb-drv: wrong utmi data width (%ld)", extract(GHWCFG4, utmi_phy_data_width)); if(!(GHWCFG4 & GHWCFG4_ded_fifo_en)) /* it seems to be multiple tx fifo support */ panicf("usb-drv: no multiple tx fifo"); if(USB_NUM_ENDPOINTS != extract(GHWCFG2, num_ep)) panicf("usb-drv: wrong endpoint number"); for (int dir = 0; dir < 2; dir++) for (unsigned i = 0; i < num_eps(dir == DIR_OUT); i++) { int ep = ((dir == DIR_IN) ? in_ep_list : out_ep_list)[i]; int type = (GHWCFG1 >> GHWCFG1_epdir_bitp(ep)) & GHWCFG1_epdir_bits; int flag = (dir == DIR_IN) ? GHWCFG1_EPDIR_IN : GHWCFG1_EPDIR_OUT; if(type != GHWCFG1_EPDIR_BIDIR && type != flag) panicf("usb-drv: EP%d not in correct direction", ep); } DOEPMSK = DEPINT_xfercompl | DEPINT_ahberr | DOEPINT_setup; DIEPMSK = DEPINT_xfercompl | DEPINT_ahberr | DIEPINT_timeout; DAINTMSK = 0xffffffff; reset_endpoints(); GINTMSK = GINTMSK_usbreset | GINTMSK_enumdone | GINTMSK_inepintr | GINTMSK_outepintr | GINTMSK_disconnect; VIC_INT_ENABLE = INTERRUPT_USB; }