static int wifi_add_dev(void) { NDEBUG("## Calling platform_driver_register\n"); platform_driver_register(&wifi_device); platform_driver_register(&wifi_device_legacy); return 0; }
extern int powersave_test (int autotest) { int ret = 0; u32 register_1 = 0; u32 register_2 = 0; nand_info->dma_on = 0; nand_info->ecc_on = 1; socle_nfc_set_ecc(nand_info); register_1 = socle_nfc_read(NF_SFR_FLCTRL); //entry power save mode socle_power_save_on_off(0); nand_info->ecc_on = 0; socle_nfc_set_ecc(nand_info); //leave power save mode socle_power_save_on_off(1); register_2 = socle_nfc_read(NF_SFR_FLCTRL); if (register_1 != register_2){ NDEBUG(" 'Power save mode' didn't work !!!\n"); ret = -1; } return ret; }
static int rtw_android_pno_enable(struct net_device *net, int pno_enable) { _adapter *padapter = (_adapter *)rtw_netdev_priv(net); struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter); if (pwrctl) { pwrctl->wowlan_pno_enable = pno_enable; NDEBUG("%s: wowlan_pno_enable: %d\n", __func__, pwrctl->wowlan_pno_enable); if (pwrctl->wowlan_pno_enable == 0) { if (pwrctl->pnlo_info != NULL) { rtw_mfree((u8 *)pwrctl->pnlo_info, sizeof(pno_nlo_info_t)); pwrctl->pnlo_info = NULL; } if (pwrctl->pno_ssid_list != NULL) { rtw_mfree((u8 *)pwrctl->pno_ssid_list, sizeof(pno_ssid_list_t)); pwrctl->pno_ssid_list = NULL; } if (pwrctl->pscan_info != NULL) { rtw_mfree((u8 *)pwrctl->pscan_info, sizeof(pno_scan_info_t)); pwrctl->pscan_info = NULL; } } return 0; } else { return -1; } }
static int socle_nand_select_lookup_test (u8 channel) { struct socle_nand_flash *flash_info = nand_info->flash_info; int ret = 0; u16 logic_block_num = 0; u16 physical_block_num = 0; u32 test_program_page_addr = socle_get_test_page_number(); socle_nand_initial_buf(BUFFER_WRITE); if(socle_nfc_page_program_memory(nand_info, test_program_page_addr, flash_info->page_size)) return -1; physical_block_num = test_program_page_addr/flash_info->page_per_block; logic_block_num = 0; socle_nfc_set_lookup( logic_block_num, physical_block_num, channel); u32 test_read_page_addr = test_program_page_addr & 0x007F; socle_nand_initial_buf(BUFFER_READ); if(socle_nfc_page_read_memory(nand_info, test_read_page_addr, flash_info->page_size)) return -1; NDEBUG("Compare TX RX in %s_function\n",__func__); if(socle_nand_compare_pattern(TEST_PATTERN_RX_ADDR,TEST_PATTERN_TX_ADDR, flash_info->page_size)) return -1; socle_nfc_release_all_lookup(); return ret; }
extern int socle_nand_word_read_program_loopback_test(void) { struct socle_nand_flash *flash_info = nand_info->flash_info; int ret = 0; u32 test_page_number; test_page_number = socle_get_test_page_number(); NDEBUG("current page =0x%x\n",test_page_number); //program page socle_nand_initial_buf(BUFFER_WRITE); if (socle_nfc_page_program1_memory(nand_info, test_page_number, 0, (u8 *) nand_info->dma_buffer, flash_info->page_size)) return -1; // FSM go to IDLE STATE socle_nfc_write_command(nand_info); //page read socle_nand_initial_buf(BUFFER_READ); if (socle_nfc_page_read1_memory(nand_info, test_page_number, 0, (u8 *)nand_info->dma_buffer, flash_info->page_size)) return -1; // FSM go to IDLE STATE socle_nfc_read_command(nand_info); //compare if(socle_nand_compare_pattern(TEST_PATTERN_RX_ADDR,TEST_PATTERN_TX_ADDR, flash_info->page_size)) return -1; return ret; }
extern int misc_nand_block_erase_test (int autotest) { int ret = 0; u32 start_block_num = 0; u32 end_block_num = 0; u32 i =0; socle_nfc_set_ecc(nand_info); if (autotest) { start_block_num = 5; end_block_num =5; } else { printf("Erase Block: Star_of_BlockNum\n"); scanf("%d\n", &start_block_num); printf("Erase Block: End_of_BlockNum\n"); scanf("%d\n", &end_block_num); } for (i = start_block_num; i<=end_block_num; i++) { NDEBUG(" Erase Block =%d\n", i); if (socle_nfc_block_erase(nand_info, i)) return -1; } return ret; }
static int wifi_suspend(struct platform_device *pdev, pm_message_t state) { NDEBUG("##> %s\n", __FUNCTION__); #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 39)) && defined(OOB_INTR_ONLY) bcmsdh_oob_intr_set(0); #endif return 0; }
static int wifi_set_carddetect(int on) { NDEBUG("%s = %d\n", __FUNCTION__, on); if (wifi_control_data && wifi_control_data->set_carddetect) { wifi_control_data->set_carddetect(on); } return 0; }
static int wifi_resume(struct platform_device *pdev) { NDEBUG("##> %s\n", __FUNCTION__); #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 39)) && defined(OOB_INTR_ONLY) if (dhd_os_check_if_up(bcmsdh_get_drvdata())) bcmsdh_oob_intr_set(1); #endif return 0; }
extern u32 socle_get_test_page_number(void) { NDEBUG("get test page number\n"); struct socle_nand_flash *flash_info= nand_info->flash_info; int block_erase_num; //erase block if (page_number == 0 || ((page_number+1) %flash_info->page_per_block)==0) { block_erase_num = (int)NAND_TEST_PAGE_ADDR/flash_info->page_per_block; NDEBUG("Block erase number = 0x%x\n", block_erase_num); if(socle_nfc_block_erase(nand_info, block_erase_num)) return -1; page_number = 0; } return NAND_TEST_PAGE_ADDR + page_number++; }
extern int misc_nand_dma_read_write_test(int autotest) { int ret = 0; u32 data_size = nand_info->flash_info->page_size; u32 data_offset = 0; if (!autotest){ printf(" DMA data_size:\n"); scanf("%d\n", &data_size); printf(" DMA data_offset:\n"); scanf("%d\n", &data_offset); } nand_info->dma_on= 1; NDEBUG("DMA from External to Internal\n"); socle_nand_initial_buf(BUFFER_WRITE); nand_info->dma_direct = NF_DMA_WRITE; if ((nand_info->dma_mode == NF_DMA_SINGLE_ADRR_DEC) | (nand_info->dma_mode== NF_DMA_BURST_ADRR_DEC)) nand_info->dma_buffer = nand_info->dma_buffer +data_size-1 ; if (socle_nfc_dma_transfer(nand_info, data_size, data_offset)) return -1; NDEBUG("DMA from Internal to External\n"); nand_info->dma_buffer = TEST_PATTERN_RX_ADDR; memset((char *) TEST_PATTERN_RX_ADDR, 0xff, TEST_PATTERN_BUF_SIZE + MAX_SPARE_SIZE); nand_info->dma_direct = NF_DMA_READ; if ((nand_info->dma_mode == NF_DMA_SINGLE_ADRR_DEC) | (nand_info->dma_mode== NF_DMA_BURST_ADRR_DEC)) nand_info->dma_buffer = nand_info->dma_buffer +data_size-1; if (socle_nfc_dma_transfer(nand_info, data_size, data_offset)) return -1; //compare if(socle_nand_compare_pattern(TEST_PATTERN_TX_ADDR,TEST_PATTERN_RX_ADDR, data_size)) ret= -1; nand_info->dma_on= 0; return ret; }
int wifi_get_mac_addr(unsigned char *buf) { NDEBUG("%s\n", __FUNCTION__); if (!buf) return -EINVAL; if (wifi_control_data && wifi_control_data->get_mac_addr) { return wifi_control_data->get_mac_addr(buf); } return -EOPNOTSUPP; }
void *wifi_get_country_code(char *ccode) { NDEBUG("%s\n", __FUNCTION__); if (!ccode) return NULL; if (wifi_control_data && wifi_control_data->get_country_code) { return wifi_control_data->get_country_code(ccode); } return NULL; }
int wifi_set_power(int on, unsigned long msec) { NDEBUG("%s = %d\n", __FUNCTION__, on); if (wifi_control_data && wifi_control_data->set_power) { wifi_control_data->set_power(on); } if (msec) msleep(msec); return 0; }
// Print spi_flash_type void prnFlashInfo(unsigned char ucChip, struct spi_flash_type sftInfo) { #if (SPI_DRIVER_MODE == 1) NDEBUG(" ========================= Registed SPI Flash Model ========================= \n"); NDEBUG("|No chipID Sft chipSize blkSize secSize pageSize sdCk opCk chipName |\n"); NDEBUG("|%2d %6xh %2xh %7xh %6xh %6xh %7xh %4d %4d %17s|\n", ucChip, sftInfo.chip_id, sftInfo.size_shift, sftInfo.chip_size, sftInfo.block_size, sftInfo.sector_size, sftInfo.page_size, sftInfo.chipClock, sftInfo.chip_clk, sftInfo.chip_name); ////////1111 2222 3333 4444 5555 6666 7777 8888 9999 aaaa NDEBUG(" ============================================================================ \n"); #else NDEBUG(" ------------------------- Force into Single IO Mode ------------------------ \n"); NDEBUG("|No chipID Sft chipSize blkSize secSize pageSize sdCk opCk chipName |\n"); NDEBUG("|%2d %6xh %2xh %7xh %6xh %6xh %7xh %4d %4d %17s|\n", ucChip, sftInfo.chip_id, sftInfo.size_shift, sftInfo.chip_size, sftInfo.block_size, sftInfo.sector_size, sftInfo.page_size, sftInfo.chipClock, sftInfo.chip_clk, sftInfo.chip_name); ////////1111 2222 3333 4444 5555 6666 7777 8888 9999 aaaa NDEBUG(" ---------------------------------------------------------------------------- \n"); #endif }
static int wifi_remove(struct platform_device *pdev) { struct wifi_platform_data *wifi_ctrl = (struct wifi_platform_data *)(pdev->dev.platform_data); NDEBUG("## %s\n", __FUNCTION__); wifi_control_data = wifi_ctrl; wifi_set_power(0, 0); /* Power Off */ wifi_set_carddetect(0); /* CardDetect (1->0) */ up(&wifi_control_sem); return 0; }
static void wifi_shutdown(struct platform_device *pdev) { struct wifi_platform_data *wifi_ctrl = (struct wifi_platform_data *)(pdev->dev.platform_data); NDEBUG("## %s\n", __FUNCTION__); wifi_control_data = wifi_ctrl; shutdown_card(); wifi_set_power(0, 0); /* Power Off */ wifi_set_carddetect(0); /* CardDetect (1->0) */ }
// get Dram Frequence unsigned int CheckDramFreq(void) //JSW:For 8196C { unsigned short usFreqBit; #if defined(CONFIG_RTL8198) unsigned short usFreqVal[] = {65, 181, 150, 125, 156, 168, 237, 193}; #elif defined(CONFIG_RTL_819XD) || defined(CONFIG_RTL_8196E) unsigned short usFreqVal[] = {156, 193, 181, 231, 212, 125, 237, 168}; #else unsigned short usFreqVal[] = {65, 78, 125, 150, 156, 168, 193, 193}; #endif usFreqBit = (0x00001C00 & (*(unsigned int*)0xb8000008)) >> 10 ; LDEBUG("CheckDramFreq:usFreqVal=%dMHZ; usFreqBit=%x; B8000008=%x;\n", usFreqVal[usFreqBit], usFreqBit, (*(unsigned int*)0xb8000008)); NDEBUG("SDRAM CLOCK:%dMHZ\n", usFreqVal[usFreqBit]); return usFreqVal[usFreqBit]; }
extern int interrupt_rnb_test(int autotest) { NDEBUG("---Interrupt RnB Test---\n"); socle_init_nfc_int(); socle_nfc_int_flag = 0; socle_nand_initial_buf(BUFFER_READ); if(socle_nfc_page_read(nand_info, NAND_TEST_PAGE_ADDR)) { printf("%s: Page read fail!\n", __func__); socle_exit_nfc_int(); return -1; } socle_exit_nfc_int(); return 0; }
extern int interrupt_protect_test(int autotest) { NDEBUG("---Interrupt Protect Test---\n"); socle_init_nfc_int(); u32 i, page_number; socle_nfc_set_protected_area(TEST_BEGIN_PROTECT_BLOCK, TEST_END_PROTECT_BLOCK); memcpy((char *)nand_info->buf_addr, (char *)TEST_PATTERN_TX_ADDR, nand_info->flash_info->page_size); for( i=TEST_BEGIN_PROTECT_BLOCK; i<TEST_END_PROTECT_BLOCK; i++) { socle_nfc_int_flag = 0; socle_nfc_protect_err_flag = 0; page_number = i*nand_info->flash_info->page_per_block; socle_nfc_page_program(nand_info, page_number); } socle_nfc_set_protected_area(0, 0); socle_exit_nfc_int(); return socle_nfc_protect_err_flag ? 0 : -1; }
int load_game(struct Game* game) { LOG("Loading save file\n"); FILE *file = fopen("save.txt", "r"); if(file == NULL) { NDEBUG("Save file doesn't exist"); LOG("Save file not found"); return 1; } char buff[BUFSIZ]; int linenum = 0; while(fgets(buff, BUFSIZ, file) != NULL) { buff[strlen(buff) - 1] = '\0'; // load in the width and height of the map so we can malloc it if(linenum == 0) { game->world->width = atoi(buff); game->world->camera->worldwidth = game->world->width; game->world->camera->x = game->world->width >> 1; LOG("Width set\n"); linenum++; //NDEBUG("width = %d", game->world->width); LOG("World width parsed: %d\n", game->world->width); continue; } if(linenum == 1) { game->world->height = atoi(buff); game->world->camera->worldheight = game->world->height; game->world->camera->y = game->world->height >> 1; linenum++; //NDEBUG("height = %d", game->world->height); //NDEBUG("%s", buff); LOG("World height parsed: %d\n", game->world->height); continue; }
extern int interrupt_dma_test(int autotest) { NDEBUG("---Interrupt DMA Test---\n"); socle_init_nfc_int(); nand_info->dma_on= 1; nand_info->dma_size= NF_DMA_SIZE_32;//NF_DMA_SIZE_16 nand_info->dma_mode = NF_DMA_BURST_8_ADDR_INC; nand_info->dma_direct = NF_DMA_READ; nand_info->dma_buffer = TEST_PATTERN_RX_ADDR; socle_nfc_set_dma(nand_info); socle_nfc_prepare_dma_transfer(nand_info, nand_info->flash_info->page_size, 0); socle_nand_initial_buf(BUFFER_READ); if(socle_nfc_page_read(nand_info, NAND_TEST_PAGE_ADDR)) { printf("%s: Page read fail!\n", __func__); socle_exit_nfc_int(); return -1; } socle_exit_nfc_int(); return 0; }
static int wifi_probe(struct platform_device *pdev) { struct wifi_platform_data *wifi_ctrl = (struct wifi_platform_data *)(pdev->dev.platform_data); int wifi_wake_gpio = 0; NDEBUG("## %s\n", __FUNCTION__); wifi_irqres = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "bcmdhd_wlan_irq"); if (wifi_irqres == NULL) wifi_irqres = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "bcm4329_wlan_irq"); else wifi_wake_gpio = wifi_irqres->start; #ifdef CONFIG_GPIO_WAKEUP printk("%s: gpio:%d wifi_wake_gpio:%d\n", __func__, wifi_irqres->start, wifi_wake_gpio); if (wifi_wake_gpio > 0) { gpio_request(wifi_wake_gpio, "oob_irq"); gpio_direction_input(wifi_wake_gpio); oob_irq = gpio_to_irq(wifi_wake_gpio); printk("%s oob_irq:%d\n", __func__, oob_irq); } else if(wifi_irqres) { oob_irq = wifi_irqres->start; printk("%s oob_irq:%d\n", __func__, oob_irq); } #endif wifi_control_data = wifi_ctrl; wifi_set_power(1, 0); /* Power On */ wifi_set_carddetect(1); /* CardDetect (0->1) */ up(&wifi_control_sem); return 0; }
int rtw_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd) { #if 1 struct rtl8192cd_priv *priv = GET_DEV_PRIV(net); int ret = 0; char *command = NULL; int cmd_num; int bytes_written = 0; #ifdef CONFIG_PNO_SUPPORT uint cmdlen = 0; uint pno_enable = 0; #endif struct android_wifi_priv_cmd priv_cmd; // _adapter* padapter = ( _adapter * ) rtw_netdev_priv(net); #ifdef CONFIG_WFD struct wifi_display_info *pwfd_info; #endif //rtw_lock_suspend(); if (!ifr->ifr_data) { NDEBUG("failed to allocate memory\n"); ret = -EINVAL; goto exit; } if (copy_from_user(&priv_cmd, ifr->ifr_data, sizeof(struct android_wifi_priv_cmd))) { NDEBUG("failed\n"); ret = -EFAULT; goto exit; } //NDEBUG("%s priv_cmd.buf=%p priv_cmd.total_len=%d priv_cmd.used_len=%d\n",__func__,priv_cmd.buf,priv_cmd.total_len,priv_cmd.used_len); command = kmalloc(priv_cmd.total_len,GFP_ATOMIC); if (!command) { NDEBUG("failed to allocate memory\n"); ret = -ENOMEM; goto exit; } if (!access_ok(VERIFY_READ, priv_cmd.buf, priv_cmd.total_len)){ NDEBUG("%s: failed to access memory\n", __FUNCTION__); ret = -EFAULT; goto exit; } #ifdef CONFIG_COMPAT if (copy_from_user(command, compat_ptr(priv_cmd.buf), (unsigned long) priv_cmd.total_len)) { #else if (copy_from_user(command, (void *)priv_cmd.buf, priv_cmd.total_len)) { #endif ret = -EFAULT; goto exit; } //NDEBUG("%s: Android private cmd \"%s\" on %s\n", __FUNCTION__, command, ifr->ifr_name); cmd_num = rtw_android_cmdstr_to_num(command); switch(cmd_num) { case ANDROID_WIFI_CMD_START: //bytes_written = wl_android_wifi_on(net); goto response; case ANDROID_WIFI_CMD_SETFWPATH: goto response; } if (!g_wifi_on) { NDEBUG("%s: Ignore private cmd \"%s\" - iface %s is down\n" ,__FUNCTION__, command, ifr->ifr_name); ret = 0; goto exit; } switch(cmd_num) { case ANDROID_WIFI_CMD_STOP: //bytes_written = wl_android_wifi_off(net); break; case ANDROID_WIFI_CMD_SCAN_ACTIVE: //rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_ACTIVE); #ifdef CONFIG_PLATFORM_MSTAR #ifdef CONFIG_IOCTL_CFG80211 adapter_wdev_data((_adapter *)rtw_netdev_priv(net))->bandroid_scan = _TRUE; #endif //CONFIG_IOCTL_CFG80211 #endif //CONFIG_PLATFORM_MSTAR break; case ANDROID_WIFI_CMD_SCAN_PASSIVE: //rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_PASSIVE); break; case ANDROID_WIFI_CMD_RSSI: // bytes_written = rtw_android_get_rssi(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_LINKSPEED: // bytes_written = rtw_android_get_link_speed(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_MACADDR: // bytes_written = rtw_android_get_macaddr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_BLOCK: // bytes_written = rtw_android_set_block(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_RXFILTER_START: //bytes_written = net_os_set_packet_filter(net, 1); break; case ANDROID_WIFI_CMD_RXFILTER_STOP: //bytes_written = net_os_set_packet_filter(net, 0); break; case ANDROID_WIFI_CMD_RXFILTER_ADD: //int filter_num = *(command + strlen(CMD_RXFILTER_ADD) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, TRUE, filter_num); break; case ANDROID_WIFI_CMD_RXFILTER_REMOVE: //int filter_num = *(command + strlen(CMD_RXFILTER_REMOVE) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, FALSE, filter_num); break; case ANDROID_WIFI_CMD_BTCOEXSCAN_START: /* TBD: BTCOEXSCAN-START */ break; case ANDROID_WIFI_CMD_BTCOEXSCAN_STOP: /* TBD: BTCOEXSCAN-STOP */ break; case ANDROID_WIFI_CMD_BTCOEXMODE: #if 0 uint mode = *(command + strlen(CMD_BTCOEXMODE) + 1) - '0'; if (mode == 1) net_os_set_packet_filter(net, 0); /* DHCP starts */ else net_os_set_packet_filter(net, 1); /* DHCP ends */ #ifdef WL_CFG80211 bytes_written = wl_cfg80211_set_btcoex_dhcp(net, command); #endif #endif break; case ANDROID_WIFI_CMD_SETSUSPENDOPT: //bytes_written = wl_android_set_suspendopt(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_SETBAND: // bytes_written = rtw_android_setband(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_GETBAND: // bytes_written = rtw_android_getband(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_COUNTRY: // bytes_written = rtw_android_set_country(net, command, priv_cmd.total_len); break; #ifdef CONFIG_PNO_SUPPORT case ANDROID_WIFI_CMD_PNOSSIDCLR_SET: //bytes_written = dhd_dev_pno_reset(net); break; case ANDROID_WIFI_CMD_PNOSETUP_SET: bytes_written = rtw_android_pno_setup(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_PNOENABLE_SET: cmdlen = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_PNOENABLE_SET]); pno_enable = *(command + cmdlen + 1) - '0'; bytes_written = rtw_android_pno_enable(net, pno_enable); break; #endif case ANDROID_WIFI_CMD_P2P_DEV_ADDR: bytes_written = rtw_android_get_p2p_dev_addr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_NOA: //int skip = strlen(CMD_P2P_SET_NOA) + 1; //bytes_written = wl_cfg80211_set_p2p_noa(net, command + skip, priv_cmd.total_len - skip); break; case ANDROID_WIFI_CMD_P2P_GET_NOA: //bytes_written = wl_cfg80211_get_p2p_noa(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_PS: //int skip = strlen(CMD_P2P_SET_PS) + 1; //bytes_written = wl_cfg80211_set_p2p_ps(net, command + skip, priv_cmd.total_len - skip); break; #ifdef RTK_NL80211 //def CONFIG_IOCTL_CFG80211 //cfg p2p case ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE: { int skip = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE]) + 3; bytes_written = rtk_cfg80211_set_wps_p2p_ie(net, command + skip, priv_cmd.total_len - skip, *(command + skip - 2) - '0'); break; } #endif //CONFIG_IOCTL_CFG80211 #ifdef CONFIG_WFD case ANDROID_WIFI_CMD_WFD_ENABLE: { // Commented by Albert 2012/07/24 // We can enable the WFD function by using the following command: // wpa_cli driver wfd-enable NDEBUG("no support now\n"); #if 0 // cfg p2p pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) pwfd_info->wfd_enable = _TRUE; break; #endif } case ANDROID_WIFI_CMD_WFD_DISABLE: { // Commented by Albert 2012/07/24 // We can disable the WFD function by using the following command: // wpa_cli driver wfd-disable NDEBUG("no support now\n"); #if 0 // cfg p2p pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) pwfd_info->wfd_enable = _FALSE; break; #endif } case ANDROID_WIFI_CMD_WFD_SET_TCPPORT: { NDEBUG("no support now\n"); // Commented by Albert 2012/07/24 // We can set the tcp port number by using the following command: // wpa_cli driver wfd-set-tcpport = 554 pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) { #ifdef CONFIG_COMPAT pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( compat_ptr(priv_cmd.buf) ); #else pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( priv_cmd.buf ); #endif } break; } case ANDROID_WIFI_CMD_WFD_SET_MAX_TPUT: { NDEBUG("no support now\n"); break; } case ANDROID_WIFI_CMD_WFD_SET_DEVTYPE: { NDEBUG("no support now\n"); // Commented by Albert 2012/08/28 // Specify the WFD device type ( WFD source/primary sink ) pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) { #ifdef CONFIG_COMPAT pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( compat_ptr(priv_cmd.buf) ); #else pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( priv_cmd.buf ); #endif pwfd_info->wfd_device_type &= WFD_DEVINFO_DUAL; } break; } #endif case ANDROID_WIFI_CMD_CHANGE_DTIM: { NDEBUG("no support now\n"); #ifdef CONFIG_LPS u8 dtim; u8 *ptr = priv_cmd.buf; ptr += 9;//string command length of "SET_DTIM"; dtim = rtw_atoi(ptr); NDEBUG("DTIM=%d\n", dtim); rtw_lps_change_dtim_cmd(padapter, dtim); #endif } break; case ANDROID_WIFI_CMD_HOSTAPD_SET_MACADDR_ACL: { //padapter->stapriv.acl_list.mode = ( u8 ) get_int_from_command(command); //NDEBUG("%s ANDROID_WIFI_CMD_HOSTAPD_SET_MACADDR_ACL mode:%d\n", __FUNCTION__, padapter->stapriv.acl_list.mode); NDEBUG("no support now\n"); break; } case ANDROID_WIFI_CMD_HOSTAPD_ACL_ADD_STA: { NDEBUG("no support now\n"); #if 0 // cfg p2p u8 addr[ETH_ALEN] = {0x00}; macstr2num(addr, command+strlen("HOSTAPD_ACL_ADD_STA")+3); // 3 is space bar + "=" + space bar these 3 chars rtw_acl_add_sta(padapter, addr); break; #endif } case ANDROID_WIFI_CMD_HOSTAPD_ACL_REMOVE_STA: { NDEBUG("no support now\n"); #if 0 // cfg p2p u8 addr[ETH_ALEN] = {0x00}; macstr2num(addr, command+strlen("HOSTAPD_ACL_REMOVE_STA")+3); // 3 is space bar + "=" + space bar these 3 chars rtw_acl_remove_sta(padapter, addr); break; #endif } #ifdef CONFIG_GTK_OL case ANDROID_WIFI_CMD_GTK_REKEY_OFFLOAD: rtw_gtk_offload(net, priv_cmd.buf); break; #endif //CONFIG_GTK_OL default: NDEBUG("Unknown PRIVATE command %s - ignored\n", command); snprintf(command, 3, "OK"); bytes_written = strlen("OK"); } response: if (bytes_written >= 0) { if ((bytes_written == 0) && (priv_cmd.total_len > 0)) command[0] = '\0'; if (bytes_written >= priv_cmd.total_len) { NDEBUG("%s: bytes_written = %d\n", __FUNCTION__, bytes_written); bytes_written = priv_cmd.total_len; } else { bytes_written++; } priv_cmd.used_len = bytes_written; #ifdef CONFIG_COMPAT if (copy_to_user(compat_ptr(priv_cmd.buf), command, bytes_written)) { #else if (copy_to_user((void *)priv_cmd.buf, command, bytes_written)) { #endif NDEBUG("%s: failed to copy data to user buffer\n", __FUNCTION__); ret = -EFAULT; } } else { ret = bytes_written; } exit: //rtw_unlock_suspend(); //cfg p2p if (command) { kfree(command); } return ret; #endif } /** * Functions for Android WiFi card detection */ #if 0 //defined(RTW_ENABLE_WIFI_CONTROL_FUNC) //cfg p2p static int g_wifidev_registered = 0; static struct semaphore wifi_control_sem; static struct wifi_platform_data *wifi_control_data = NULL; static struct resource *wifi_irqres = NULL; static int wifi_add_dev(void); static void wifi_del_dev(void); int rtw_android_wifictrl_func_add(void) { int ret = 0; sema_init(&wifi_control_sem, 0); ret = wifi_add_dev(); if (ret) { NDEBUG("%s: platform_driver_register failed\n", __FUNCTION__); return ret; } g_wifidev_registered = 1; /* Waiting callback after platform_driver_register is done or exit with error */ if (down_timeout(&wifi_control_sem, msecs_to_jiffies(1000)) != 0) { ret = -EINVAL; NDEBUG("%s: platform_driver_register timeout\n", __FUNCTION__); } return ret; } void rtw_android_wifictrl_func_del(void) { if (g_wifidev_registered) { wifi_del_dev(); g_wifidev_registered = 0; } } void *wl_android_prealloc(int section, unsigned long size) { void *alloc_ptr = NULL; if (wifi_control_data && wifi_control_data->mem_prealloc) { alloc_ptr = wifi_control_data->mem_prealloc(section, size); if (alloc_ptr) { NDEBUG("success alloc section %d\n", section); if (size != 0L) memset(alloc_ptr, 0, size); return alloc_ptr; } } NDEBUG("can't alloc section %d\n", section); return NULL; }
static void shutdown_card(void) { u32 addr; u8 tmp8, cnt=0; if (NULL == g_test_adapter) { NDEBUG("%s: padapter==NULL\n", __FUNCTION__); return; } #ifdef CONFIG_FWLPS_IN_IPS LeaveAllPowerSaveMode(g_test_adapter); #endif // CONFIG_FWLPS_IN_IPS // Leave SDIO HCI Suspend addr = 0x10250086; rtw_write8(g_test_adapter, addr, 0); do { tmp8 = rtw_read8(g_test_adapter, addr); cnt++; NDEBUG(FUNC_ADPT_FMT ": polling SDIO_HSUS_CTRL(0x%x)=0x%x, cnt=%d\n", FUNC_ADPT_ARG(g_test_adapter), addr, tmp8, cnt); if (tmp8 & BIT(1)) break; if (cnt >= 100) { NDEBUG(FUNC_ADPT_FMT ": polling 0x%x[1]==1 FAIL!!\n", FUNC_ADPT_ARG(g_test_adapter), addr); break; } rtw_mdelay_os(10); } while (1); // unlock register I/O rtw_write8(g_test_adapter, 0x1C, 0); // enable power down function // 0x04[4] = 1 // 0x05[7] = 1 addr = 0x04; tmp8 = rtw_read8(g_test_adapter, addr); tmp8 |= BIT(4); rtw_write8(g_test_adapter, addr, tmp8); NDEBUG(FUNC_ADPT_FMT ": read after write 0x%x=0x%x\n", FUNC_ADPT_ARG(g_test_adapter), addr, rtw_read8(g_test_adapter, addr)); addr = 0x05; tmp8 = rtw_read8(g_test_adapter, addr); tmp8 |= BIT(7); rtw_write8(g_test_adapter, addr, tmp8); NDEBUG(FUNC_ADPT_FMT ": read after write 0x%x=0x%x\n", FUNC_ADPT_ARG(g_test_adapter), addr, rtw_read8(g_test_adapter, addr)); // lock register page0 0x0~0xB read/write rtw_write8(g_test_adapter, 0x1C, 0x0E); g_test_adapter->bSurpriseRemoved = _TRUE; NDEBUG(FUNC_ADPT_FMT ": bSurpriseRemoved=%d\n", FUNC_ADPT_ARG(g_test_adapter), g_test_adapter->bSurpriseRemoved); #ifdef CONFIG_CONCURRENT_MODE if (g_test_adapter->pbuddy_adapter) { PADAPTER pbuddy; pbuddy = g_test_adapter->pbuddy_adapter; pbuddy->bSurpriseRemoved = _TRUE; NDEBUG(FUNC_ADPT_FMT ": buddy(" ADPT_FMT ") bSurpriseRemoved=%d\n", FUNC_ADPT_ARG(g_test_adapter), ADPT_ARG(pbuddy), pbuddy->bSurpriseRemoved); } #endif // CONFIG_CONCURRENT_MODE }
extern int interrupt_test(int autotest) { #if 1 int ret = 0; nand_info->irq_on = 1; //socle_init_nfc_int(); //all interrupt, DMA, RnB, Protect NDEBUG("Start Test Interrupt\n"); ret = test_item_ctrl(&nfc_ctrl_interrupt_test_container, autotest); nand_info->irq_on = 0; //socle_exit_nfc_int(); return ret; #else struct socle_nand_flash *flash_info = nand_info->flash_info; int ret = 0; u32 block_erase_num = 0; socle_nfc_int_flag = 0; socle_nfc_int_state = 0; nand_info->dma_on = 0; nand_info->ecc_on = 0; socle_nfc_set_ecc(nand_info); //test RnB interrupt NDEBUG("------------Int test 1--------------------\n"); nand_info->dma_on = 1; nand_info->dma_size= NF_DMA_SIZE_8;//NF_DMA_SIZE_16 nand_info->dma_mode = NF_DMA_BURST_8_ADDR_INC; socle_nand_initial_buf(BUFFER_READ); if (!(socle_nfc_interrupt_page_read(nand_info, NAND_TEST_PAGE_ADDR, flash_info->page_size) & NAND_STATUS_READY)) return -1; free_irq(NAND_INT); #if 0//def NFC_CTRL_DEBUG show_data((u8 *)nand_info->buf_addr, 128); show_data((u8 *)TEST_PATTERN_RX_ADDR, 128); #endif //compare if(socle_nand_compare_pattern(TEST_PATTERN_RX_ADDR,nand_info->buf_addr, flash_info->page_size)) ret= -1; //test Prot_IE interrupt NDEBUG("------------Int test 2--------------------\n"); socle_nfc_set_protected_area(TEST_BEGIN_PROTECT_BLOCK, TEST_END_PROTECT_BLOCK); socle_nand_initial_buf(BUFFER_WRITE); if (!(socle_nfc_interrupt_page_program(nand_info, (TEST_BEGIN_PROTECT_BLOCK+1) *(flash_info->page_per_block),flash_info->page_size) & NAND_STATUS_WP)) ret = -1; free_irq(NAND_INT); NDEBUG(" Protect socle_nfc_int_state =0x%x\n",socle_nfc_int_state); socle_nfc_set_protected_area(0, 0); //Test DMA IE NDEBUG("------------Int test 3--------------------\n"); nand_info->dma_on= 1; nand_info->dma_size= NF_DMA_SIZE_8;//NF_DMA_SIZE_16 nand_info->dma_mode = NF_DMA_BURST_8_ADDR_INC; if ((page_number %flash_info->page_per_block)==0) { block_erase_num = (int)(NAND_TEST_PAGE_ADDR + page_number)/flash_info->page_per_block; NDEBUG("Block erase number = 0x%x\n", block_erase_num); if(socle_nfc_block_erase(nand_info, block_erase_num)) return -1; if (socle_nfc_read_status(nand_info) & NAND_STATUS_FAIL) return -1; page_number = 0; } page_number ++; NDEBUG("===Int write page\n"); socle_nand_initial_buf(BUFFER_WRITE); if (!(socle_nfc_dma_interrupt_page_program(nand_info, NAND_TEST_PAGE_ADDR + page_number, flash_info->page_size) & NAND_STATUS_READY)) return -1; free_irq(NAND_INT); NDEBUG("===Int read page\n"); socle_nand_initial_buf(BUFFER_READ); if (!(socle_nfc_dma_interrupt_page_read(nand_info, NAND_TEST_PAGE_ADDR + page_number, flash_info->page_size) & NAND_STATUS_READY)) return -1; free_irq(NAND_INT); //compare if(socle_nand_compare_pattern(TEST_PATTERN_TX_ADDR,TEST_PATTERN_RX_ADDR, nand_info->flash_info->page_size)) ret= -1; socle_nfc_write(socle_nfc_read( NF_SFR_FLCTRL) &~ (NF_CTRL_INT_EN|NF_CTRL_ACC_ERR_EN|NF_CTRL_PROT_IE|NF_CTRL_RNB_IE|NF_CTRL_DMA_IE|NF_CTRL_DMA_TRIGGER|NF_CTRL_TRANS_COMPLETE) , NF_SFR_FLCTRL); return ret; #endif }
static void wifi_del_dev(void) { NDEBUG("## Unregister platform_driver_register\n"); platform_driver_unregister(&wifi_device); platform_driver_unregister(&wifi_device_legacy); }
static int rtw_android_pno_setup(struct net_device *net, char *command, int total_len) { pno_ssid_t pno_ssids_local[MAX_PNO_LIST_COUNT]; int res = -1; int nssid = 0; cmd_tlv_t *cmd_tlv_temp; char *str_ptr; int tlv_size_left; int pno_time = 0; int pno_repeat = 0; int pno_freq_expo_max = 0; int cmdlen = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_PNOSETUP_SET]) + 1; #ifdef CONFIG_PNO_SET_DEBUG int i; char *p; p = pno_in_example; total_len = sizeof(pno_in_example); str_ptr = p + cmdlen; #else str_ptr = command + cmdlen; #endif if (total_len < (cmdlen + sizeof(cmd_tlv_t))) { NDEBUG("%s argument=%d less min size\n", __func__, total_len); goto exit_proc; } tlv_size_left = total_len - cmdlen; cmd_tlv_temp = (cmd_tlv_t *)str_ptr; memset(pno_ssids_local, 0, sizeof(pno_ssids_local)); if ((cmd_tlv_temp->prefix == PNO_TLV_PREFIX) && (cmd_tlv_temp->version == PNO_TLV_VERSION) && (cmd_tlv_temp->subver == PNO_TLV_SUBVERSION)) { str_ptr += sizeof(cmd_tlv_t); tlv_size_left -= sizeof(cmd_tlv_t); if ((nssid = rtw_parse_ssid_list_tlv(&str_ptr, pno_ssids_local, MAX_PNO_LIST_COUNT, &tlv_size_left)) <= 0) { NDEBUG("SSID is not presented or corrupted ret=%d\n", nssid); goto exit_proc; } else { if ((str_ptr[0] != PNO_TLV_TYPE_TIME) || (tlv_size_left <= 1)) { NDEBUG("%s scan duration corrupted field size %d\n", __func__, tlv_size_left); goto exit_proc; } str_ptr++; pno_time = simple_strtoul(str_ptr, &str_ptr, 16); NDEBUG("%s: pno_time=%d\n", __func__, pno_time); if (str_ptr[0] != 0) { if ((str_ptr[0] != PNO_TLV_FREQ_REPEAT)) { NDEBUG("%s pno repeat : corrupted field\n", __func__); goto exit_proc; } str_ptr++; pno_repeat = simple_strtoul(str_ptr, &str_ptr, 16); NDEBUG("%s :got pno_repeat=%d\n", __FUNCTION__, pno_repeat); if (str_ptr[0] != PNO_TLV_FREQ_EXPO_MAX) { NDEBUG("%s FREQ_EXPO_MAX corrupted field size\n", __func__); goto exit_proc; } str_ptr++; pno_freq_expo_max = simple_strtoul(str_ptr, &str_ptr, 16); NDEBUG("%s: pno_freq_expo_max=%d\n", __func__, pno_freq_expo_max); } } } else { NDEBUG("%s get wrong TLV command\n", __FUNCTION__); goto exit_proc; } res = rtw_dev_pno_set(net, pno_ssids_local, nssid, pno_time, pno_repeat, pno_freq_expo_max); #ifdef CONFIG_PNO_SET_DEBUG rtw_dev_pno_debug(net); #endif exit_proc: return res; }
int rtw_android_priv_cmd2(struct net_device *dev, struct ifreq *ifr, int cmd) { struct rtl8192cd_priv *priv = GET_DEV_PRIV(priv); // char *command2 = NULL; int cmd_num2; int idx; int skip; int ret1=0; struct android_wifi_priv_cmd priv_cmd_s; u8 tmpbuf[360]; int cmdtype; memset(&priv_cmd_s , 0 , sizeof(struct android_wifi_priv_cmd)); if (!ifr->ifr_data) { NDEBUG("fail!\n"); return -1; } if (copy_from_user(&priv_cmd_s, ifr->ifr_data, sizeof(struct android_wifi_priv_cmd))) { NDEBUG("fail\n"); return -1; } NDEBUG2("buf=[%s]\n",priv_cmd_s.buf); if(priv_cmd_s.total_len<360){ if (copy_from_user(tmpbuf, priv_cmd_s.buf, priv_cmd_s.total_len)) { NDEBUG("fail\n"); return -1; } #if 0 for(idx=0;idx<priv_cmd_s.total_len;idx++){ if( (idx+1) %16==0) panic_printk("\n"); panic_printk("[%02X]",tmpbuf[idx]); } #endif }else{ NDEBUG("IE len more than 1024,chk!!!\n"); return -1; } #if 1 cmd_num2 = rtw_android_cmdstr_to_num(tmpbuf); switch(cmd_num2) { case ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE: { skip = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE]) + 3; cmdtype = *(tmpbuf + skip - 2) - '0'; #if 0 if(cmdtype==2){ NDEBUG("cmdtype=[%d],buf[%s],len[%d]\n",cmdtype,priv_cmd_s.buf,priv_cmd_s.total_len); for(idx=0;idx<priv_cmd_s.total_len;idx++) printk("[%02x]",priv_cmd_s.buf[idx]); } #endif #ifdef RTK_NL80211 ret1 = rtk_cfg80211_set_wps_p2p_ie(priv, (tmpbuf + skip) , (priv_cmd_s.total_len - skip), cmdtype); #endif break; } default: NDEBUG(" !! unknow cmd_num[%d]\n",cmd_num2); } #endif return 0; }