/** * @ingroup finsh * * This function set the echo mode of finsh shell. * * FINSH_OPTION_ECHO=0x01 is echo mode, other values are none-echo mode. * * @param echo the echo mode */ void finsh_set_echo(rt_uint32_t echo) { RT_ASSERT(shell != RT_NULL); shell->echo_mode = (rt_uint8_t)echo; }
/** * @ingroup finsh * * This function gets the echo mode of finsh shell. * * @return the echo mode */ rt_uint32_t finsh_get_echo() { RT_ASSERT(shell != RT_NULL); return shell->echo_mode; }
void finsh_set_echo(rt_uint32_t enable) { RT_ASSERT(shell != RT_NULL); shell->echo_mode = enable; }
/** * @ingroup finsh * * This function returns current finsh shell input device. * * @return the finsh shell input device name is returned. */ const char *finsh_get_device() { RT_ASSERT(shell != RT_NULL); return shell->device->parent.name; }
int rtl_usb_probe(struct usb_interface *intf, const struct usb_device_id *id, struct rtl_hal_cfg *rtl_hal_cfg) { int err; struct ieee80211_hw *hw = NULL; struct rtl_priv *rtlpriv = NULL; struct usb_device *udev; struct rtl_usb_priv *usb_priv; hw = ieee80211_alloc_hw(sizeof(struct rtl_priv) + sizeof(struct rtl_usb_priv), &rtl_ops); if (!hw) { RT_ASSERT(false, "ieee80211 alloc failed\n"); return -ENOMEM; } rtlpriv = hw->priv; rtlpriv->usb_data = kzalloc(RTL_USB_MAX_RX_COUNT * sizeof(u32), GFP_KERNEL); if (!rtlpriv->usb_data) return -ENOMEM; /* this spin lock must be initialized early */ spin_lock_init(&rtlpriv->locks.usb_lock); INIT_WORK(&rtlpriv->works.fill_h2c_cmd, rtl_fill_h2c_cmd_work_callback); INIT_WORK(&rtlpriv->works.lps_change_work, rtl_lps_change_work_callback); rtlpriv->usb_data_index = 0; init_completion(&rtlpriv->firmware_loading_complete); SET_IEEE80211_DEV(hw, &intf->dev); udev = interface_to_usbdev(intf); usb_get_dev(udev); usb_priv = rtl_usbpriv(hw); memset(usb_priv, 0, sizeof(*usb_priv)); usb_priv->dev.intf = intf; usb_priv->dev.udev = udev; usb_set_intfdata(intf, hw); /* init cfg & intf_ops */ rtlpriv->rtlhal.interface = INTF_USB; rtlpriv->cfg = rtl_hal_cfg; rtlpriv->intf_ops = &rtl_usb_ops; rtl_dbgp_flag_init(hw); /* Init IO handler */ _rtl_usb_io_handler_init(&udev->dev, hw); rtlpriv->cfg->ops->read_chip_version(hw); /*like read eeprom and so on */ rtlpriv->cfg->ops->read_eeprom_info(hw); err = _rtl_usb_init(hw); if (err) goto error_out; rtl_usb_init_sw(hw); /* Init mac80211 sw */ err = rtl_init_core(hw); if (err) { RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Can't allocate sw for mac80211\n"); goto error_out; } if (rtlpriv->cfg->ops->init_sw_vars(hw)) { RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Can't init_sw_vars\n"); goto error_out; } rtlpriv->cfg->ops->init_sw_leds(hw); err = ieee80211_register_hw(hw); if (err) { RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Can't register mac80211 hw.\n"); err = -ENODEV; goto error_out; } rtlpriv->mac80211.mac80211_registered = 1; set_bit(RTL_STATUS_INTERFACE_START, &rtlpriv->status); return 0; error_out: rtl_deinit_core(hw); _rtl_usb_io_handler_release(hw); usb_put_dev(udev); complete(&rtlpriv->firmware_loading_complete); return -ENODEV; }
static int rtl_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, struct ieee80211_vif *vif, struct ieee80211_sta *sta, struct ieee80211_key_conf *key) { struct rtl_priv *rtlpriv = rtl_priv(hw); u8 key_type = NO_ENCRYPTION; u8 key_idx; bool group_key = false; bool wep_only = false; int err = 0; u8 mac_addr[ETH_ALEN]; u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; u8 zero_addr[ETH_ALEN] = { 0 }; if (rtlpriv->cfg->mod_params->sw_crypto || rtlpriv->sec.use_sw_sec) { RT_TRACE(COMP_ERR, DBG_WARNING, ("not open hw encryption\n")); return -ENOSPC; /*User disabled HW-crypto */ } /* To support IBSS, use sw-crypto for GTK */ if(((vif->type == NL80211_IFTYPE_ADHOC) || (vif->type == NL80211_IFTYPE_MESH_POINT)) && !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) return -ENOSPC; RT_TRACE(COMP_SEC, DBG_DMESG, ("%s hardware based encryption for keyidx: %d, mac: %pM\n", cmd == SET_KEY ? "Using" : "Disabling", key->keyidx, sta ? sta->addr : bcast_addr)); rtlpriv->sec.being_setkey = true; rtl_ips_nic_on(hw); mutex_lock(&rtlpriv->locks.conf_mutex); /* <1> get encryption alg */ switch (key->cipher) { case WLAN_CIPHER_SUITE_WEP40: key_type = WEP40_ENCRYPTION; RT_TRACE(COMP_SEC, DBG_DMESG, ("alg:WEP40\n")); break; case WLAN_CIPHER_SUITE_WEP104: RT_TRACE(COMP_SEC, DBG_DMESG, ("alg:WEP104\n")); key_type = WEP104_ENCRYPTION; break; case WLAN_CIPHER_SUITE_TKIP: key_type = TKIP_ENCRYPTION; RT_TRACE(COMP_SEC, DBG_DMESG, ("alg:TKIP\n")); break; case WLAN_CIPHER_SUITE_CCMP: key_type = AESCCMP_ENCRYPTION; RT_TRACE(COMP_SEC, DBG_DMESG, ("alg:CCMP\n")); break; case WLAN_CIPHER_SUITE_AES_CMAC: /* HW don't support CMAC encryption, * use software CMAC encryption */ key_type = AESCMAC_ENCRYPTION; RT_TRACE(COMP_SEC, DBG_DMESG, ("alg:CMAC\n")); RT_TRACE(COMP_SEC, DBG_DMESG, ("HW don't support CMAC encryption, " "use software CMAC encryption\n")); err = -EOPNOTSUPP; goto out_unlock; default: RT_TRACE(COMP_ERR, DBG_EMERG, ("alg_err:%x!!!!:\n", key->cipher)); goto out_unlock; } if(key_type == WEP40_ENCRYPTION || key_type == WEP104_ENCRYPTION || vif->type == NL80211_IFTYPE_ADHOC) rtlpriv->sec.use_defaultkey = true; /* <2> get key_idx */ key_idx = (u8) (key->keyidx); if (key_idx > 3) goto out_unlock; /* <3> if pairwise key enable_hw_sec */ group_key = !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE); /* wep always be group key, but there are two conditions: * 1) wep only: is just for wep enc, in this condition * rtlpriv->sec.pairwise_enc_algorithm == NO_ENCRYPTION * will be true & enable_hw_sec will be set when wep * ke setting. * 2) wep(group) + AES(pairwise): some AP like cisco * may use it, in this condition enable_hw_sec will not * be set when wep key setting */ /* we must reset sec_info after lingked before set key, * or some flag will be wrong*/ if (vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_MESH_POINT) { if (!group_key || key_type == WEP40_ENCRYPTION || key_type == WEP104_ENCRYPTION) { if (group_key) { wep_only = true; } rtlpriv->cfg->ops->enable_hw_sec(hw); } } else { if ((!group_key) || (vif->type == NL80211_IFTYPE_ADHOC) || rtlpriv->sec.pairwise_enc_algorithm == NO_ENCRYPTION) { if (rtlpriv->sec.pairwise_enc_algorithm == NO_ENCRYPTION && (key_type == WEP40_ENCRYPTION || key_type == WEP104_ENCRYPTION)) wep_only = true; rtlpriv->sec.pairwise_enc_algorithm = key_type; RT_TRACE(COMP_SEC, DBG_DMESG, ("set enable_hw_sec, key_type:%x(OPEN:0 WEP40:" "1 TKIP:2 AES:4 WEP104:5)\n", key_type)); rtlpriv->cfg->ops->enable_hw_sec(hw); } } /* <4> set key based on cmd */ switch (cmd) { case SET_KEY: if (wep_only) { RT_TRACE(COMP_SEC, DBG_DMESG, ("set WEP(group/pairwise) key\n")); /* Pairwise key with an assigned MAC address. */ rtlpriv->sec.pairwise_enc_algorithm = key_type; rtlpriv->sec.group_enc_algorithm = key_type; /*set local buf about wep key. */ memcpy(rtlpriv->sec.key_buf[key_idx], key->key, key->keylen); rtlpriv->sec.key_len[key_idx] = key->keylen; memcpy(mac_addr, zero_addr, ETH_ALEN); } else if (group_key) { /* group key */ RT_TRACE(COMP_SEC, DBG_DMESG, ("set group key\n")); /* group key */ rtlpriv->sec.group_enc_algorithm = key_type; /*set local buf about group key. */ memcpy(rtlpriv->sec.key_buf[key_idx], key->key, key->keylen); rtlpriv->sec.key_len[key_idx] = key->keylen; memcpy(mac_addr, bcast_addr, ETH_ALEN); } else { /* pairwise key */ RT_TRACE(COMP_SEC, DBG_DMESG, ("set pairwise key\n")); if (!sta) { RT_ASSERT(false, ("pairwise key withnot" "mac_addr\n")); err = -EOPNOTSUPP; goto out_unlock; } /* Pairwise key with an assigned MAC address. */ rtlpriv->sec.pairwise_enc_algorithm = key_type; /*set local buf about pairwise key. */ memcpy(rtlpriv->sec.key_buf[PAIRWISE_KEYIDX], key->key, key->keylen); rtlpriv->sec.key_len[PAIRWISE_KEYIDX] = key->keylen; rtlpriv->sec.pairwise_key = rtlpriv->sec.key_buf[PAIRWISE_KEYIDX]; memcpy(mac_addr, sta->addr, ETH_ALEN); } rtlpriv->cfg->ops->set_key(hw, key_idx, mac_addr, group_key, key_type, wep_only, false); /* <5> tell mac80211 do something: */ /*must use sw generate IV, or can not work !!!!. */ key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; key->hw_key_idx = key_idx; if (key_type == TKIP_ENCRYPTION) key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; /*use software CCMP encryption for management frames (MFP) */ if (key_type == AESCCMP_ENCRYPTION) key->flags |= IEEE80211_KEY_FLAG_SW_MGMT; break; case DISABLE_KEY: RT_TRACE(COMP_SEC, DBG_DMESG, ("disable key delete one entry\n")); /*set local buf about wep key. */ if (vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_MESH_POINT) { if (sta) rtl_cam_del_entry(hw, sta->addr); } memset(rtlpriv->sec.key_buf[key_idx], 0, key->keylen); rtlpriv->sec.key_len[key_idx] = 0; memcpy(mac_addr, zero_addr, ETH_ALEN); /* *mac80211 will delete entrys one by one, *so don't use rtl_cam_reset_all_entry *or clear all entry here. */ rtl_cam_delete_one_entry(hw, mac_addr, key_idx); break; default: RT_TRACE(COMP_ERR, DBG_EMERG, ("cmd_err:%x!!!!:\n", cmd)); } out_unlock: mutex_unlock(&rtlpriv->locks.conf_mutex); rtlpriv->sec.being_setkey = false; return err; }
/* Draw tab bars of @param notebook. @param dc should be initialized and * finished outside this function. Don't pass @param notebook or @param dc as * RT_NULL, it should be checked outside. */ static void _rtgui_notebook_draw_bar(struct rtgui_notebook *notebook, struct rtgui_dc *dc) { int index; struct rtgui_rect rect; struct rtgui_rect text_rect; #ifdef RTGUI_USING_NOTEBOOK_IMAGE struct rtgui_image *image = RT_NULL; struct rtgui_rect image_rect; #endif RT_ASSERT((notebook != RT_NULL) && (dc != RT_NULL)); if (notebook->flag == RTGUI_NOTEBOOK_NOTAB) return; _rtgui_notebook_get_bar_rect(notebook, &rect); rtgui_dc_fill_rect(dc, &rect); if (notebook->flag == RTGUI_NOTEBOOK_TOP || notebook->flag == RTGUI_NOTEBOOK_BOTTOM) { rect.x2 = rect.x1 + notebook->tab_w; /* draw tab bar */ for (index = 0; index < notebook->count; index++) { if (notebook->current == index) { #ifdef RTGUI_USING_NOTEBOOK_IMAGE if (notebook->childs[index].pressed_image != RT_NULL) image = notebook->childs[index].pressed_image; else #endif rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_SUNKEN); } else { #ifdef RTGUI_USING_NOTEBOOK_IMAGE if (notebook->childs[index].unpressed_image != RT_NULL) image = notebook->childs[index].unpressed_image; else #endif rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_BOX); } rtgui_font_get_metrics(RTGUI_WIDGET_FONT(notebook), notebook->childs[index].title, &text_rect); rtgui_rect_moveto_align(&rect, &text_rect, RTGUI_ALIGN_CENTER); #ifdef RTGUI_USING_NOTEBOOK_IMAGE if (image != RT_NULL) { image_rect.x1 = 0; image_rect.y1 = RTGUI_WIDGET_DEFAULT_MARGIN; image_rect.x2 = image_rect.x1 + image->w; image_rect.y2 = image_rect.y1 + image->h; rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL); rtgui_image_blit(image, dc, &image_rect); } if (image != RT_NULL) { int text_height = text_rect.y2 - text_rect.y1; text_rect.y1 = image_rect.y2 + RTGUI_WIDGET_DEFAULT_MARGIN; text_rect.y2 = text_rect.y1 + text_height; } image = RT_NULL; #endif rtgui_dc_draw_text(dc, notebook->childs[index].title, &text_rect); /* move to next tab */ rect.x1 = rect.x2; rect.x2 = rect.x1 + notebook->tab_w; } } else { rect.y2 = rect.y1 + notebook->tab_h; /* draw tab bar */ for (index = 0; index < notebook->count; index++) { if (notebook->current == index) { #ifdef RTGUI_USING_NOTEBOOK_IMAGE if (notebook->childs[index].pressed_image != RT_NULL) image = notebook->childs[index].pressed_image; else #endif rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_SUNKEN); } else { #ifdef RTGUI_USING_NOTEBOOK_IMAGE if (notebook->childs[index].unpressed_image != RT_NULL) image = notebook->childs[index].unpressed_image; else #endif rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_BOX); } rtgui_font_get_metrics(RTGUI_WIDGET_FONT(notebook), notebook->childs[index].title, &text_rect); rtgui_rect_moveto_align(&rect, &text_rect, RTGUI_ALIGN_CENTER); #ifdef RTGUI_USING_NOTEBOOK_IMAGE if (image != RT_NULL) { image_rect.x1 = 0; image_rect.y1 = RTGUI_WIDGET_DEFAULT_MARGIN; image_rect.x2 = image->w; image_rect.y2 = image_rect.y1 + image->h; rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL); rtgui_image_blit(image, dc, &image_rect); } if (image != RT_NULL) { int text_height = text_rect.y2 - text_rect.y1; text_rect.y1 = image_rect.y2 + RTGUI_WIDGET_DEFAULT_MARGIN; text_rect.y2 = text_rect.y1 + text_height; } image = RT_NULL; #endif rtgui_dc_draw_text(dc, notebook->childs[index].title, &text_rect); /* move to next tab */ rect.y1 = rect.y2; rect.y2 = rect.y1 + notebook->tab_h; } } }
/** * Allocate a block of memory with a minimum of 'size' bytes. * * @param size is the minimum size of the requested block in bytes. * * @return pointer to allocated memory or NULL if no free memory was found. */ void *rt_malloc(rt_size_t size) { rt_size_t ptr, ptr2; struct heap_mem *mem, *mem2; RT_DEBUG_NOT_IN_INTERRUPT; if (size == 0) return RT_NULL; if (size != RT_ALIGN(size, RT_ALIGN_SIZE)) RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d, but align to %d\n", size, RT_ALIGN(size, RT_ALIGN_SIZE))); else RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d\n", size)); /* alignment size */ size = RT_ALIGN(size, RT_ALIGN_SIZE); if (size > mem_size_aligned) { RT_DEBUG_LOG(RT_DEBUG_MEM, ("no memory\n")); return RT_NULL; } /* every data block must be at least MIN_SIZE_ALIGNED long */ if (size < MIN_SIZE_ALIGNED) size = MIN_SIZE_ALIGNED; /* take memory semaphore */ rt_sem_take(&heap_sem, RT_WAITING_FOREVER); for (ptr = (rt_uint8_t *)lfree - heap_ptr; ptr < mem_size_aligned - size; ptr = ((struct heap_mem *)&heap_ptr[ptr])->next) { mem = (struct heap_mem *)&heap_ptr[ptr]; if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) { /* mem is not used and at least perfect fit is possible: * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */ if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) { /* (in addition to the above, we test if another struct heap_mem (SIZEOF_STRUCT_MEM) containing * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem') * -> split large block, create empty remainder, * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size, * struct heap_mem would fit in but no data between mem2 and mem2->next * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty * region that couldn't hold data, but when mem->next gets freed, * the 2 regions would be combined, resulting in more free memory */ ptr2 = ptr + SIZEOF_STRUCT_MEM + size; /* create mem2 struct */ mem2 = (struct heap_mem *)&heap_ptr[ptr2]; mem2->used = 0; mem2->next = mem->next; mem2->prev = ptr; /* and insert it between mem and mem->next */ mem->next = ptr2; mem->used = 1; if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM) { ((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2; } #ifdef RT_MEM_STATS used_mem += (size + SIZEOF_STRUCT_MEM); if (max_mem < used_mem) max_mem = used_mem; #endif } else { /* (a mem2 struct does no fit into the user data space of mem and mem->next will always * be used at this point: if not we have 2 unused structs in a row, plug_holes should have * take care of this). * -> near fit or excact fit: do not split, no mem2 creation * also can't move mem->next directly behind mem, since mem->next * will always be used at this point! */ mem->used = 1; #ifdef RT_MEM_STATS used_mem += mem->next - ((rt_uint8_t*)mem - heap_ptr); if (max_mem < used_mem) max_mem = used_mem; #endif } /* set memory block magic */ mem->magic = HEAP_MAGIC; if (mem == lfree) { /* Find next free block after mem and update lowest free pointer */ while (lfree->used && lfree != heap_end) lfree = (struct heap_mem *)&heap_ptr[lfree->next]; RT_ASSERT(((lfree == heap_end) || (!lfree->used))); } rt_sem_release(&heap_sem); RT_ASSERT((rt_uint32_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uint32_t)heap_end); RT_ASSERT((rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0); RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE-1)) == 0); RT_DEBUG_LOG(RT_DEBUG_MEM, ("allocate memory at 0x%x, size: %d\n", (rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM), (rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr)))); RT_OBJECT_HOOK_CALL(rt_malloc_hook, (((void*)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM)), size)); /* return the memory data except mem struct */ return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM; } } rt_sem_release(&heap_sem); return RT_NULL; }
int rtgui_notebook_get_count(struct rtgui_notebook *notebook) { RT_ASSERT(notebook != RT_NULL); return notebook->count; }
rt_int16_t rtgui_notebook_get_current_index(struct rtgui_notebook *notebook) { RT_ASSERT(notebook != RT_NULL); return notebook->current; }
struct rt_spi_message *rt_spi_transfer_message(struct rt_spi_device *device, struct rt_spi_message *message) { rt_err_t result; struct rt_spi_message *index; RT_ASSERT(device != RT_NULL); /* get first message */ index = message; if (index == RT_NULL) return index; result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER); if (result != RT_EOK) { rt_set_errno(-RT_EBUSY); return index; } /* reset errno */ rt_set_errno(RT_EOK); /* configure SPI bus */ if (device->bus->owner != device) { /* not the same owner as current, re-configure SPI bus */ result = device->bus->ops->configure(device, &device->config); if (result == RT_EOK) { /* set SPI bus owner */ device->bus->owner = device; } else { /* configure SPI bus failed */ rt_set_errno(-RT_EIO); result = 0; goto __exit; } } /* transmit each SPI message */ while (index != RT_NULL) { /* transmit SPI message */ result = device->bus->ops->xfer(device, index); if (result == 0) { rt_set_errno(-RT_EIO); break; } index = index->next; } __exit: /* release bus lock */ rt_mutex_release(&(device->bus->lock)); return index; }
rt_err_t rt_spi_send_then_recv(struct rt_spi_device *device, const void *send_buf, rt_size_t send_length, void *recv_buf, rt_size_t recv_length) { rt_err_t result; struct rt_spi_message message; RT_ASSERT(device != RT_NULL); RT_ASSERT(device->bus != RT_NULL); result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER); if (result == RT_EOK) { if (device->bus->owner != device) { /* not the same owner as current, re-configure SPI bus */ result = device->bus->ops->configure(device, &device->config); if (result == RT_EOK) { /* set SPI bus owner */ device->bus->owner = device; } else { /* configure SPI bus failed */ result = -RT_EIO; goto __exit; } } /* send data */ message.send_buf = send_buf; message.recv_buf = RT_NULL; message.length = send_length; message.cs_take = 1; message.cs_release = 0; message.next = RT_NULL; result = device->bus->ops->xfer(device, &message); if (result == 0) { result = -RT_EIO; goto __exit; } /* recv data */ message.send_buf = RT_NULL; message.recv_buf = recv_buf; message.length = recv_length; message.cs_take = 0; message.cs_release = 1; message.next = RT_NULL; result = device->bus->ops->xfer(device, &message); if (result == 0) { result = -RT_EIO; goto __exit; } result = RT_EOK; } else { return -RT_EIO; } __exit: rt_mutex_release(&(device->bus->lock)); return result; }
rt_err_t rt_completion_wait(struct rt_completion *completion, rt_int32_t timeout) { rt_err_t result; rt_base_t level; rt_thread_t thread; RT_ASSERT(completion != RT_NULL); result = RT_EOK; thread = rt_thread_self(); level = rt_hw_interrupt_disable(); if (completion->flag != RT_COMPLETED) { /* only one thread can suspend on complete */ RT_ASSERT(rt_list_isempty(&(completion->suspended_list))); if (timeout == 0) { result = -RT_ETIMEOUT; goto __exit; } else { /* reset thread error number */ thread->error = RT_EOK; /* suspend thread */ rt_thread_suspend(thread); /* add to suspended list */ rt_list_insert_before(&(completion->suspended_list), &(thread->tlist)); /* current context checking */ RT_DEBUG_NOT_IN_INTERRUPT; /* start timer */ if (timeout > 0) { /* reset the timeout of thread timer and start it */ rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout); rt_timer_start(&(thread->thread_timer)); } /* enable interrupt */ rt_hw_interrupt_enable(level); /* do schedule */ rt_schedule(); /* thread is waked up */ result = thread->error; level = rt_hw_interrupt_disable(); /* clean completed flag */ completion->flag = RT_UNCOMPLETED; } } __exit: rt_hw_interrupt_enable(level); return result; }
/* return the size of struct dirent*/ static int dfs_jffs2_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) { cyg_file * jffs2_file; struct CYG_UIO_TAG uio_s; struct CYG_IOVEC_TAG iovec; struct jffs2_dirent jffs2_d; struct dirent * d; rt_uint32_t index; #if !defined (CYGPKG_FS_JFFS2_RET_DIRENT_DTYPE) struct jffs2_stat s; cyg_mtab_entry * mte; char * fullname; #endif int result; RT_ASSERT(file->data != RT_NULL); jffs2_file = (cyg_file*)(file->data); //set jffs2_d memset(&jffs2_d, 0, sizeof(struct jffs2_dirent)); //set CYG_UIO_TAG uio_s uio_s.uio_iov = &iovec; uio_s.uio_iov->iov_base = &jffs2_d; uio_s.uio_iov->iov_len = sizeof(struct jffs2_dirent);; uio_s.uio_iovcnt = 1; //must be 1 uio_s.uio_offset = 0;//not used... uio_s.uio_resid = uio_s.uio_iov->iov_len; //seem no use in jffs2; #if !defined (CYGPKG_FS_JFFS2_RET_DIRENT_DTYPE) result = _find_fs(&mte, file->fs->dev_id); if (result) return -DFS_STATUS_ENOENT; #endif /* make integer count, usually count is 1 */ count = (count / sizeof(struct dirent)) * sizeof(struct dirent); if (count == 0) return -DFS_STATUS_EINVAL; index = 0; /* usually, the while loop should only be looped only once! */ while (1) { d = dirp + index; rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_dir_read(jffs2_file, &uio_s); rt_mutex_release(&jffs2_lock); /* if met a error or all entry are read over, break while*/ if (result || jffs2_d.d_name[0] == 0) break; #if defined (CYGPKG_FS_JFFS2_RET_DIRENT_DTYPE) switch(jffs2_d.d_type & JFFS2_S_IFMT) { case JFFS2_S_IFREG: d->d_type = DFS_DT_REG; break; case JFFS2_S_IFDIR: d->d_type = DFS_DT_DIR; break; default: d->d_type = DFS_DT_UNKNOWN; break; } #else fullname = rt_malloc(FILE_PATH_MAX); if(fullname == RT_NULL) return -DFS_STATUS_ENOMEM; /* make a right entry */ if ((file->path[0] == '/') ) { if (file->path[1] == 0) strcpy(fullname, jffs2_d.d_name); else rt_sprintf(fullname, "%s/%s", file->path+1, jffs2_d.d_name); } else rt_sprintf(fullname, "%s/%s", file->path, jffs2_d.d_name); rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_porting_stat(mte, mte->root, fullname, (void *)&s); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); rt_free(fullname); /* convert to dfs stat structure */ switch(s.st_mode & JFFS2_S_IFMT) { case JFFS2_S_IFREG: d->d_type = DFS_DT_REG; break; case JFFS2_S_IFDIR: d->d_type = DFS_DT_DIR; break; default: d->d_type = DFS_DT_UNKNOWN; break; } #endif /* write the rest fields of struct dirent* dirp */ d->d_namlen = rt_strlen(jffs2_d.d_name); d->d_reclen = (rt_uint16_t)sizeof(struct dirent); rt_strncpy(d->d_name, jffs2_d.d_name, d->d_namlen + 1); index ++; if (index * sizeof(struct dirent) >= count) break; } if (result) return jffs2_result_to_dfs(result); return index * sizeof(struct dirent); }
static rt_err_t eth_init(rt_device_t device ) { struct eth_device *eth_device = (struct eth_device *)device; RT_ASSERT(eth_device != RT_NULL); s32 ijk; s32 status = 0; u64 dma_addr; u32 Mac_changed = 0; struct pbuf *pbuf; u8 macaddr[6] = DEFAULT_MAC_ADDRESS; struct rt_eth_dev *dev = ð_dev; struct synopGMACNetworkAdapter *adapter = dev->priv; synopGMACdevice * gmacdev = (synopGMACdevice *)adapter->synopGMACdev; synopGMAC_reset(gmacdev); synopGMAC_attach(gmacdev,(regbase + MACBASE),(regbase + DMABASE), DEFAULT_PHY_BASE, macaddr); synopGMAC_read_version(gmacdev); synopGMAC_set_mdc_clk_div(gmacdev,GmiiCsrClk3); gmacdev->ClockDivMdc = synopGMAC_get_mdc_clk_div(gmacdev); init_phy(adapter->synopGMACdev); rt_kprintf("tx desc_queue\n"); synopGMAC_setup_tx_desc_queue(gmacdev,TRANSMIT_DESC_SIZE, RINGMODE); synopGMAC_init_tx_desc_base(gmacdev); rt_kprintf("rx desc_queue\n"); synopGMAC_setup_rx_desc_queue(gmacdev,RECEIVE_DESC_SIZE, RINGMODE); synopGMAC_init_rx_desc_base(gmacdev); DEBUG_MES("DmaRxBaseAddr = %08x\n",synopGMACReadReg(gmacdev->DmaBase,DmaRxBaseAddr)); // u32 dmaRx_Base_addr = synopGMACReadReg(gmacdev->DmaBase,DmaRxBaseAddr); // rt_kprintf("first_desc_addr = 0x%x\n", dmaRx_Base_addr); #ifdef ENH_DESC_8W synopGMAC_dma_bus_mode_init(gmacdev, DmaBurstLength32 | DmaDescriptorSkip2 | DmaDescriptor8Words ); #else //synopGMAC_dma_bus_mode_init(gmacdev, DmaBurstLength4 | DmaDescriptorSkip1); synopGMAC_dma_bus_mode_init(gmacdev, DmaBurstLength4 | DmaDescriptorSkip2); #endif synopGMAC_dma_control_init(gmacdev,DmaStoreAndForward |DmaTxSecondFrame|DmaRxThreshCtrl128); status = synopGMAC_check_phy_init(adapter); synopGMAC_mac_init(gmacdev); synopGMAC_pause_control(gmacdev); #ifdef IPC_OFFLOAD synopGMAC_enable_rx_chksum_offload(gmacdev); synopGMAC_rx_tcpip_chksum_drop_enable(gmacdev); #endif u32 skb; do{ skb = (u32)plat_alloc_memory(RX_BUF_SIZE); //should skb aligned here? if(skb == RT_NULL){ rt_kprintf("ERROR in skb buffer allocation\n"); break; } dma_addr = plat_dma_map_single(gmacdev,(void *)skb,RX_BUF_SIZE); //获取 skb 的 dma 地址 status = synopGMAC_set_rx_qptr(gmacdev,dma_addr,RX_BUF_SIZE,(u32)skb,0,0,0); if(status < 0) { rt_kprintf("status < 0!!\n"); plat_free_memory((void *)skb); } }while(status >= 0 && (status < (RECEIVE_DESC_SIZE - 1))); synopGMAC_clear_interrupt(gmacdev); synopGMAC_disable_mmc_tx_interrupt(gmacdev, 0xFFFFFFFF); synopGMAC_disable_mmc_rx_interrupt(gmacdev, 0xFFFFFFFF); synopGMAC_disable_mmc_ipc_rx_interrupt(gmacdev, 0xFFFFFFFF); // synopGMAC_disable_interrupt_all(gmacdev); synopGMAC_enable_interrupt(gmacdev, DmaIntEnable); synopGMAC_enable_dma_rx(gmacdev); synopGMAC_enable_dma_tx(gmacdev); plat_delay(DEFAULT_LOOP_VARIABLE); synopGMAC_check_phy_init(adapter); synopGMAC_mac_init(gmacdev); rt_timer_init(&dev->link_timer, "link_timer", synopGMAC_linux_cable_unplug_function, (void *)adapter, RT_TICK_PER_SECOND, RT_TIMER_FLAG_PERIODIC); rt_timer_start(&dev->link_timer); #ifdef RT_USING_GMAC_INT_MODE /* installl isr */ DEBUG_MES("%s\n", __FUNCTION__); rt_hw_interrupt_install(LS1C_MAC_IRQ, eth_rx_irq, RT_NULL, "e0_isr"); rt_hw_interrupt_umask(LS1C_MAC_IRQ); #else rt_timer_init(&dev->rx_poll_timer, "rx_poll_timer", eth_rx_irq, (void *)adapter, 1, RT_TIMER_FLAG_PERIODIC); rt_timer_start(&dev->rx_poll_timer); #endif /*RT_USING_GMAC_INT_MODE*/ rt_kprintf("eth_inited!\n"); return RT_EOK; }
enum error_type enable_uart(void) { RT_ASSERT(UBRR1H != 0 || UBRR1L != 0, ERROR_TYPE_BAUD_RATE_NOT_SET); UCSR1B = (1 << RXEN1) | (1 << TXEN1); return ERROR_TYPE_OK; }
/** * this function will normalize a path according to specified parent directory * and file name. * * @param directory the parent path * @param filename the file name * * @return the built full file path (absolute path) */ char *dfs_normalize_path(const char *directory, const char *filename) { char *fullpath; char *dst0, *dst, *src; /* check parameters */ RT_ASSERT(filename != RT_NULL); #ifdef DFS_USING_WORKDIR if (directory == RT_NULL) /* shall use working directory */ directory = &working_directory[0]; #else if ((directory == RT_NULL) && (filename[0] != '/')) { rt_kprintf(NO_WORKING_DIR); return RT_NULL; } #endif if (filename[0] != '/') /* it's a absolute path, use it directly */ { fullpath = rt_malloc(strlen(directory) + strlen(filename) + 2); if (fullpath == RT_NULL) return RT_NULL; /* join path and file name */ rt_snprintf(fullpath, strlen(directory) + strlen(filename) + 2, "%s/%s", directory, filename); } else { fullpath = rt_strdup(filename); /* copy string */ if (fullpath == RT_NULL) return RT_NULL; } src = fullpath; dst = fullpath; dst0 = dst; while (1) { char c = *src; if (c == '.') { if (!src[1]) src ++; /* '.' and ends */ else if (src[1] == '/') { /* './' case */ src += 2; while ((*src == '/') && (*src != '\0')) src ++; continue; } else if (src[1] == '.') { if (!src[2]) { /* '..' and ends case */ src += 2; goto up_one; } else if (src[2] == '/') { /* '../' case */ src += 3; while ((*src == '/') && (*src != '\0')) src ++; goto up_one; } } } /* copy up the next '/' and erase all '/' */ while ((c = *src++) != '\0' && c != '/') *dst ++ = c; if (c == '/') { *dst ++ = '/'; while (c == '/') c = *src++; src --; } else if (!c) break; continue; up_one: dst --; if (dst < dst0) { rt_free(fullpath); return RT_NULL; } while (dst0 < dst && dst[-1] != '/') dst --; } *dst = '\0'; /* remove '/' in the end of path if exist */ dst --; if ((dst != fullpath) && (*dst == '/')) *dst = '\0'; return fullpath; }
// // Description: // Validate the object list contains all the required parameters of the id. // E.g., for P2PSVC_OBJ_HDR_ID_ACT_SEEK, the obj list shall contain list of // [svc-name, svc-hash, svc-info-req]. // Each required obj shall appear just once. // Order is not important. // RT_STATUS P2PSvc_ValidateActionParam( IN u4Byte id, IN PP2PSVC_OBJ_LIST pObjList ) { RT_STATUS rtStatus = RT_STATUS_SUCCESS; int actSpecIdx = 0; int nParams = 0; int paramIdx = 0; PP2PSVC_ACTION_SPEC_ENTRY pActSpec = NULL; do { // Search table for(actSpecIdx = 0; P2PSVC_OBJ_HDR_ID_ACT_UNKNOWN != lP2PSvcActionSpecTab[actSpecIdx].actId; actSpecIdx++) { if(id == lP2PSvcActionSpecTab[actSpecIdx].actId) { pActSpec = &(lP2PSvcActionSpecTab[actSpecIdx]); break; } } RT_ASSERT(pActSpec, ("p2psvc_AddSeekInfo(): Spec of P2PSVC_OBJ_HDR_ID_ACT_SEEK not specified in the action spec table\n")); // Count # of parameters if (pActSpec != NULL) { for (nParams = 0; P2PSVC_OBJ_HDR_ID_DATA_UNKNOWN != pActSpec->paramList[nParams]; nParams++) {} } // Shall have exactly 1 set of parameters for(paramIdx = 0; paramIdx < nParams; paramIdx++) {// foreach required parameter u4Byte objIter = 0; PRT_OBJECT_HEADER pCurObj = NULL; u4Byte nOccurrence = 0; for(objIter = 0; objIter < pObjList->nObjs; objIter++) { pCurObj = P2PSVC_OBJ_LIST_GET_OBJ(pObjList, objIter); if(pCurObj->Id == pActSpec->paramList[paramIdx]) nOccurrence++; } if(0 == nOccurrence) { RT_TRACE_F(COMP_P2P, DBG_WARNING, ("param (0x%08X) not found\n", pActSpec->paramList[paramIdx])); rtStatus = RT_STATUS_INVALID_PARAMETER; break; } else if(1 < nOccurrence && P2PSVC_OBJ_HDR_ID_DATA_UNKNOWN != pActSpec->paramList[paramIdx] ) { RT_TRACE_F(COMP_P2P, DBG_WARNING, ("id of cur obj (%u) occur more than once: %u\n", pCurObj->Id, nOccurrence)); rtStatus = RT_STATUS_INVALID_PARAMETER; break; } } if(RT_STATUS_SUCCESS != rtStatus) { break; } }while(FALSE); // Dump raw data if invalid if(RT_STATUS_SUCCESS != rtStatus) { RT_TRACE_F(COMP_P2P, DBG_WARNING, ("[WARNING] info action param\n")); RT_PRINT_DATA(COMP_P2P, DBG_WARNING, "ObjList:\n", pObjList, P2PSVC_OBJ_LIST_LEN(pObjList)); } return rtStatus; }
void rtgui_checkbox_set_onbutton(rtgui_checkbox_t* checkbox, rtgui_onbutton_func_t func) { RT_ASSERT(checkbox != RT_NULL); checkbox->on_button = func; }
static rt_bool_t rtgui_textbox_onkey(struct rtgui_object* widget, rtgui_event_t* event) { rtgui_textbox_t* box = RTGUI_TEXTBOX(widget); struct rtgui_event_kbd* ekbd = (struct rtgui_event_kbd*)event; rt_size_t length; rt_uint16_t posbak = box->position; RT_ASSERT(box != RT_NULL); RT_ASSERT(ekbd != RT_NULL); /* handle the key at down time and nothing to do with up */ if (RTGUI_KBD_IS_UP(ekbd)) return RT_TRUE; if (box->dis_length == 0) { rtgui_rect_t rect; rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect); if (box->font_width == 0) return RT_FALSE; box->dis_length = (rtgui_rect_width(rect) - 5) / box->font_width; } length = rt_strlen(box->text); if(ekbd->key == RTGUIK_DELETE) {/* delete latter character */ if(box->position == length - 1) { box->text[box->position] = '\0'; } else { char *c; /* remove character */ for(c = &box->text[box->position]; c[1] != '\0'; c++) *c = c[1]; *c = '\0'; } } else if(ekbd->key == RTGUIK_BACKSPACE) {/* delete front character */ if(box->position == 0) return RT_FALSE; else if(box->position == length) { box->text[box->position-1] = '\0'; box->position --; } else if(box->position != 0) { /* remove current character */ if(box->position != 0) { char *c; /* remove character */ for(c = &box->text[box->position - 1]; c[1] != '\0'; c++) *c = c[1]; *c = '\0'; } box->position --; } } else if(ekbd->key == RTGUIK_LEFT) {/* move to prev */ if(box->position > 0) { box->position --; } } else if(ekbd->key == RTGUIK_RIGHT) {/* move to next */ if(box->position < length) { box->position ++; } } else if(ekbd->key == RTGUIK_HOME) {/* move cursor to start */ box->position = 0; } else if(ekbd->key == RTGUIK_END) {/* move cursor to end */ box->position = length; } else if(ekbd->key == RTGUIK_RETURN) { if(box->on_enter != RT_NULL) { box->on_enter(box, event); } } else if(ekbd->key == RTGUIK_NUMLOCK) { /* change numlock state */ /* extern void update_number_lock(void); update_number_lock(); */ } else { if(isprint(ekbd->key)) {/* it's may print character */ /* no buffer on this line */ if(box->flag & RTGUI_TEXTBOX_DIGIT) {/* only input digit */ if(!isdigit(ekbd->key)) {/* exception: '.' and '-' */ if(ekbd->key != '.' && ekbd->key !='-')return RT_FALSE; if(ekbd->key == '.' && strchr(box->text,'.'))return RT_FALSE; if(ekbd->key == '-') { if(length+1 > box->line_length) return RT_FALSE; if(length+1 > box->dis_length) return RT_FALSE; if(strchr(box->text,'-')) { char* c; for(c = &box->text[0]; c != &box->text[length]; c++) *c = *(c+1); box->text[length] = '\0'; box->position --; goto _exit; } else { char* c; for(c = &box->text[length]; c != &box->text[0]; c--) *c = *(c-1); box->text[0] = '-'; box->text[length+1] = '\0'; box->position ++; goto _exit; } } } } if(length+1 > box->line_length) return RT_FALSE; if(length+1 > box->dis_length) return RT_FALSE; if(box->position <= length-1) { char* c; for(c = &box->text[length]; c != &box->text[box->position]; c--) *c = *(c-1); box->text[length+1] = '\0'; } box->text[box->position] = ekbd->key; box->position ++; } } _exit: if(box->flag & RTGUI_TEXTBOX_CARET_SHOW) { if(box->caret_timer != RT_NULL) rtgui_timer_stop(box->caret_timer); box->flag &= ~RTGUI_TEXTBOX_CARET_SHOW; rtgui_textbox_draw_caret(box, posbak);/* refresh it */ if(box->caret_timer != RT_NULL) rtgui_timer_start(box->caret_timer); } /* re-draw text box */ rtgui_textbox_ondraw(box); rtgui_textbox_init_caret(box, box->position); box->flag |= RTGUI_TEXTBOX_CARET_SHOW; rtgui_textbox_draw_caret(box,box->position); return RT_TRUE; }
rt_bool_t rtgui_checkbox_event_handler(struct rtgui_object* object, struct rtgui_event* event) { struct rtgui_widget *widget; struct rtgui_checkbox *box = (struct rtgui_checkbox*)widget; RT_ASSERT(widget != RT_NULL); RT_ASSERT(event != RT_NULL); widget = RTGUI_WIDGET(object); box = RTGUI_CHECKBOX(object); switch (event->type) { case RTGUI_EVENT_PAINT: #ifndef RTGUI_USING_SMALL_SIZE if (widget->on_draw != RT_NULL) { return widget->on_draw(widget, event); } else #endif rtgui_theme_draw_checkbox(box); break; case RTGUI_EVENT_MOUSE_BUTTON: { if (RTGUI_WIDGET_IS_ENABLE(widget) && !RTGUI_WIDGET_IS_HIDE(widget)) { struct rtgui_event_mouse* emouse = (struct rtgui_event_mouse*)event; if (emouse->button & RTGUI_MOUSE_BUTTON_LEFT && emouse->button & RTGUI_MOUSE_BUTTON_UP) { /* set focus */ rtgui_widget_focus(widget); if (box->status_down & RTGUI_CHECKBOX_STATUS_UNCHECKED) { /* check it */ box->status_down = RTGUI_CHECKBOX_STATUS_CHECKED; } else { /* un-check it */ box->status_down = RTGUI_CHECKBOX_STATUS_UNCHECKED; } } /* draw checkbox */ rtgui_theme_draw_checkbox(box); #ifndef RTGUI_USING_SMALL_SIZE /* call user callback */ if (widget->on_mouseclick != RT_NULL) { return widget->on_mouseclick(widget, event); } #endif if (box->on_button != RT_NULL) { box->on_button(widget, event); return RT_TRUE; } } return RT_TRUE; } } return RT_FALSE; }
void rtgui_button_set_pressed_image(rtgui_button_t* btn, rtgui_image_t* image) { RT_ASSERT(btn != RT_NULL); btn->pressed_image = image; }
int recv_comm(int fd, unsigned char *buffer, rt_size_t size, struct timeval *timeout) { struct timeval t; int ret = 0; rt_size_t drv_recved = 0; int recved = 0, need = size; int timeout_cnt = 0; unsigned char *c = RT_NULL; fd_set readSet; RT_ASSERT(RT_NULL != buffer); if(fd == -1) { return -1; } t.tv_sec = 0; t.tv_usec = 100000; if(RT_NULL == timeout) { /* Wait forever approximate, it's a large time. */ timeout_cnt = 0xffffffff; } else { timeout_cnt = (timeout->tv_sec * 1000 * 1000 + timeout->tv_usec)/(t.tv_sec * 1000 * 1000 + t.tv_usec); } while(1) { FD_ZERO(&readSet); FD_SET(fd, &readSet); ret = select(fd+1,&readSet,RT_NULL,RT_NULL,&t); if(ret < 0) { rt_kprintf("select error %d\n",ret); break; } else if(ret == 0) { /* timeout */ timeout_cnt--; if(timeout_cnt == 0) { rt_kprintf("need %d data in timeout %d ms,but only %d recved.\n", size, timeout->tv_sec * 1000 + timeout->tv_usec / 1000, recved); recved = 0; break; } } else { if(FD_ISSET(fd, &readSet)) { c = &buffer[size - need]; ioctl(fd, FIONREAD, &drv_recved); /* check poll and ioctl */ RT_ASSERT(drv_recved != 0); drv_recved = (drv_recved > need ? need : drv_recved); recved = read(fd, c, drv_recved); if(recved != drv_recved) { rt_kprintf("fatal error %s(%d).\n",__FUNCTION__,__LINE__); RT_ASSERT(0); recved = 0; break; } need -= recved; if(need) { continue; } else if (need == 0) { recved = size; break; } else { rt_kprintf("fatal error %s(%d).\n",__FUNCTION__,__LINE__); RT_ASSERT(0); } } } } return recved; }