int avila_get_npe_esa( int index, uint8_t *buf ) { char npe_mac[6]= {0x00,0x00,0x00,0x00,0x00,0x00}; extern char saved_command_line[]; int i; int val; int retVal = -1; for ( i=0;i<strlen(saved_command_line);i++ ) { int found = 0; if ( index ) { if ( strncmp(saved_command_line+i,"NPE1",4)==0 ) { found = 1; } } else if ( strncmp(saved_command_line+i,"NPE0",4)==0 ) { found = 1; } if ( found ) { //printk("Index = %i %s\n", i,&saved_command_line[i] ); sscanf(&saved_command_line[i+ 5],"0x%x",&val); npe_mac[0]=val; sscanf(&saved_command_line[i+10],"0x%x",&val); npe_mac[1]=val; sscanf(&saved_command_line[i+15],"0x%x",&val); npe_mac[2]=val; sscanf(&saved_command_line[i+20],"0x%x",&val); npe_mac[3]=val; sscanf(&saved_command_line[i+25],"0x%x",&val); npe_mac[4]=val; sscanf(&saved_command_line[i+30],"0x%x",&val); npe_mac[5]=val; print_deb("NPE%d address: %02X:%02X:%02X:%02X:%02X:%02X \n", index, npe_mac[0],npe_mac[1],npe_mac[2],npe_mac[3],npe_mac[4],npe_mac[5]); break; } } if ( i != strlen(saved_command_line) ) { // We found a mac address. memcpy(buf,npe_mac,6); retVal = 0; } else { // We didn't find a mac address. print_deb("No NPE%d MAC address on command line\n", index); retVal = -1 } return retVal; }
int ti1610_ioctl_priv_proc_tl(tiwlan_req_t *req_data) { struct net_device *dev = req_data->drv->netdev; tiioctl_req_t *req = (tiioctl_req_t *) req_data->u.req.p1; static unsigned int drv_started = 0; static UINT8 IoCompleteFlag ; ULONG *data = (ULONG *) req_data->u.req.p2; int res = -EINVAL; print_deb("priv_ioctl_proc(): cmd=%ld, data=%p (user_data=%lx), lenght=%ld\n", req->cmd, data, req->user_data_pointer, req->length); if( !drv_started && (req->cmd != TIWLN_DRIVER_STATUS_SET)) { /* Dm: Fix */ return res; } switch( req->cmd ) { case TIWLN_DRIVER_STATUS_SET: if(*data) res = tiwlan_start_drv( (tiwlan_net_dev_t *)dev->priv ); else res = tiwlan_stop_drv( (tiwlan_net_dev_t *)dev->priv ); if( res == OK ) drv_started = !drv_started; break; case TIWLN_SEND_EAPOL_PACKET: res = os_sendPacket(dev, data, req->length); break; #ifdef TI_DBG case TIWLN_DRIVER_DEBUG_PRINT: res = util_hal_debug_print(dev, data); break; #endif /* TI_DBG */ default: { res = DispatchCommand(&req_data->drv->adapter, req->cmd, &req->length, req->length, data,&IoCompleteFlag ); /* If we do not have to send complete to user back then set the Falg to FALSE The Complete will be sent from another contect of command completion from FW */ if(IoCompleteFlag == FALSE) { req_data->u.req.reply_expected = FALSE; /****** TO DO - This solution will have a problem in case of two async ioctrls (in case of two utility adapters). ******/ /* Store the semaphore for later competion */ (req_data->drv->adapter).IoctlComp = &(req_data->u.req.comp); /* Store the pointer of the result status for later competion */ (req_data->drv->adapter).pCompleteReply = &(req_data->u.reply); } } } return res; }
static int avila_get_ofdm_mac_addr( uint8_t *buf ) { static char npe_mac[6]= {0x00,0x00,0x00,0x00,0x00,0x00}; extern char saved_command_line[]; int i; int val; for ( i=0;i<strlen(saved_command_line);i++ ) { if ( strncmp(saved_command_line+i,"OFDM",4)==0 ) { //printk("Index = %i %s\n", i,&saved_command_line[i] ); sscanf(&saved_command_line[i+ 5],"0x%x",&val); npe_mac[0]= (uint8_t)val; sscanf(&saved_command_line[i+10],"0x%x",&val); npe_mac[1]= (uint8_t)val; sscanf(&saved_command_line[i+15],"0x%x",&val); npe_mac[2]= (uint8_t)val; sscanf(&saved_command_line[i+20],"0x%x",&val); npe_mac[3]= (uint8_t)val; sscanf(&saved_command_line[i+25],"0x%x",&val); npe_mac[4]= (uint8_t)val; sscanf(&saved_command_line[i+30],"0x%x",&val); npe_mac[5]= (uint8_t)val; print_deb("OFDM address: %02X:%02X:%02X:%02X:%02X:%02X \n",npe_mac[0],npe_mac[1],npe_mac[2],npe_mac[3],npe_mac[4],npe_mac[5]); break; } } if ( i != strlen(saved_command_line) ) { // We found mac address. memcpy(buf,npe_mac,6); retVal = 0; } else { // We didn't find mac address. print_deb("No OFDM MAC address on bootline\n"); retVal = -1 } return retVal; }
/** * @brief Save the npe mac address in eeprom. */ int eeprom_set_npe_esa ( uint8_t *mac ) { int i; for ( i = 0; i < EEPROM_ETHA_LEN; i++ ) { print_deb("mac[%d] = 0x%x\n", i, mac[i]); ws_eeprom_write(EEPROM_ETHA_OFF + i, mac[i]); mdelay(100); } return 0; }
int util_hal_debug_print(struct net_device *dev, ULONG *data) { hal_print_param_t *p = (hal_print_param_t *) data; UINT32 opt_data = 0; if( p->optional_param ) { if( copy_from_user(&opt_data, p->optional_param, sizeof(opt_data) ) ) return -EFAULT; } print_deb("HAL_DEBUG_PRINT: func_id=%d, param=%x\n", p->func_id, opt_data ); #ifdef TI_DBG debugFunction(CONFIG_MGR(dev), p->func_id, &opt_data ); #endif return 0; }
void print_priv_ioctl_params(struct net_device *dev, tiioctl_req_t *req, char *extra) { print_deb(" priv_ioctl_params(*dev:%p,*req:%p, *extra:%p)\n", dev, req, extra); print_deb(" wrqu.point: user_data=%p, length=%ld, cmd=%ld\n", (void *) req->user_data_pointer, req->length, req->cmd ); print_deb(" wrqu dump: "); print_memory_dump((char *) req, sizeof(*req) ); print_deb("\n"); if( extra ) { print_deb(" extra (%p) :", extra ); print_memory_dump(extra, req->length ); print_deb("\n"); } }
void NdisReadConfiguration(OUT PNDIS_STATUS status, OUT PNDIS_CONFIGURATION_PARAMETER * param_value, IN NDIS_HANDLE config_handle, IN PNDIS_STRING keyword, IN NDIS_PARAMETER_TYPE param_type) { char *name = keyword->Buffer; char *s, *buf = init_file, *end_buf = init_file + init_file_length; static int count = 0; *status = NDIS_STATUS_FAILURE; *param_value = pNdisParm; if (!count) { print_deb("\n++++++++++++\n%s+++++++++++\n", init_file); count++; } if (!name || !*name || !init_file || !init_file_length) return; memset(pNdisParm, 0, sizeof(NDIS_CONFIGURATION_PARAMETER)); while (buf < end_buf) { buf = ltrim(buf); s = mem_str(buf, name, end_buf); if (!s) break; buf = ltrim(s + strlen(name)); if (*buf == '=') buf++; else { /*print_err("\n...init_config err: delim not found (=): ** %s **\n", buf ); */ buf = s + 1; /*strlen(name); */ continue; } buf = ltrim(buf); if (param_type == NdisParameterString) { char *remark = NULL; s = strchr(buf, '\n'); if (!s) s = buf + strlen(buf); remark = memchr(buf, '#', s - buf); /* skip remarks */ if (remark) { do { /* remove whitespace */ remark--; } while (*remark == ' ' || *remark == '\t'); pNdisParm->ParameterData.StringData.Length = remark - buf + 1; } else pNdisParm->ParameterData.StringData.Length = s - buf; pNdisParm->ParameterData.StringData.Buffer = (TI_UINT8 *) & pNdisParm->StringBuffer[0]; pNdisParm->ParameterData.StringData.MaximumLength = NDIS_MAX_STRING_LEN; if (!pNdisParm->ParameterData.StringData.Length > NDIS_MAX_STRING_LEN) { *status = NDIS_STATUS_BUFFER_TOO_SHORT; return; } memcpy(pNdisParm->ParameterData.StringData.Buffer, buf, pNdisParm->ParameterData.StringData.Length); print_info("NdisReadConfiguration(): %s = (%d)'%s'\n", name, pNdisParm->ParameterData.StringData.Length, pNdisParm->ParameterData.StringData.Buffer); } else if (param_type == NdisParameterInteger) { char *end_p; pNdisParm->ParameterData.IntegerData = simple_strtol(buf, &end_p, 0); if (end_p && *end_p && *end_p != ' ' && *end_p != '\n' && *end_p != '\r' && *end_p != '\t') { print_err ("\n...init_config: invalid int value for <%s> : %s\n", name, buf); return; } /*print_deb(" NdisReadConfiguration(): buf = %p (%.20s)\n", buf, buf ); */ print_info("NdisReadConfiguration(): %s = %d\n", name, (TI_INT32) pNdisParm->ParameterData. IntegerData); } else { print_err ("NdisReadConfiguration(): unknow parameter type %d for %s\n", param_type, name); return; } *status = NDIS_STATUS_SUCCESS; return; } return; }
int ti1610_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) { tiioctl_req_t *req = (tiioctl_req_t *) &rq->ifr_ifru; char *extra, *kbuf = NULL; int res, aval_data_size = ((char *) req + sizeof(*req)) - (char *)&req->user_data_pointer; /* = ~4 bytes */ /*int is_get_cmd = (req->cmd_type & IOCTL_GET);*/ print_deb("ti1610_do_ioctl(cmd=%lu(%s%s)) - user_data_pointer=0x%lx, len = %lu, aval_data_size=%d\n", req->cmd, (req->cmd_type & IOCTL_GET) ? "GET" : "", (req->cmd_type & IOCTL_SET) ? "SET" : "", req->user_data_pointer, req->length, aval_data_size ); /* driver is already initialized */ if ((req->cmd == TIWLN_SET_INIT_INFO) && (((tiwlan_net_dev_t *)dev->priv)->adapter.CoreHalCtx)) { return 0; } if( req->length > aval_data_size ) { if( req->user_data_pointer == 0 ) return -EFAULT; print_deb("ti1610_do_ioctl() - alloc %ld bytes\n", req->length ); kbuf = extra = os_memoryAlloc(NULL,req->length); #ifdef TI_MEM_ALLOC_TRACE os_printf("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, req->length, GFP_KERNEL, req->length); #endif/*I_MEM_ALLOC_TRACE*/ if( !extra ) return -ENOBUFS; if( req->cmd_type & IOCTL_SET ) { if( copy_from_user(extra, (void *) req->user_data_pointer, req->length) ) return -EFAULT; } else { os_memoryZero( NULL, extra, req->length ); } } else extra = (char *) &req->user_data_pointer; /* Driver initialization must be performed in process context. The rest is handled in the context of dedicated tasklet */ if (req->cmd == TIWLN_SET_INIT_INFO) { tiwlan_dev_init_t *init_info = (tiwlan_dev_init_t *)extra; print_deb("TIWLN_SET_INIT_INFO: el=%d il=%d, fl=%d\n", init_info?init_info->eeprom_image_length:0, init_info?init_info->init_file_length:0, init_info?init_info->firmware_image_length:0 ); res = tiwlan_init_drv((tiwlan_net_dev_t *)dev->priv, init_info); } #ifdef DRIVER_PROFILING else if (req->cmd == TIWLAN_PROFILING_REPORT) { res = tiwlan_profile_report((tiwlan_net_dev_t *)dev->priv); } else if (req->cmd == TIWLAN_PROFILING_CPU_ESTIMATOR_CMD) { /* get the command cpu estimator command parameter */ unsigned int command_param = *((unsigned int *)extra); /* extract the command type which is the MSB byte of the command param*/ unsigned int command_type = 0xFF & (command_param >> 24); /* extract the data of the command which are the 3 LSB bytes of the command param */ unsigned int command_data = 0xFFFFFF & command_param; /* execute the command according to its type */ switch (command_type) { case TIWLAN_PROFILING_CPU_ESTIMATOR_CMD_START: res = tiwlan_profile_cpu_usage_estimator_start((tiwlan_net_dev_t *)dev->priv, /* the data in this case is the estimator resolution in milliseconds */ command_data * 1000); break; case TIWLAN_PROFILING_CPU_ESTIMATOR_CMD_STOP: res = tiwlan_profile_cpu_usage_estimator_stop((tiwlan_net_dev_t *)dev->priv); break; case TIWLAN_PROFILING_CPU_ESTIMATOR_CMD_RESET: res =tiwlan_profile_cpu_usage_estimator_reset((tiwlan_net_dev_t *)dev->priv); break; default: res = 0; printk("\n\n%s: cpu usage estimator unknow command: param = %x\n\n\n", __FUNCTION__, command_param); } }