int dhd_iscan_request(void * dhdp, uint16 action) { int rc; wl_iscan_params_t params; dhd_pub_t *dhd = dhd_bus_pub(dhdp); char buf[WLC_IOCTL_SMLEN]; DHD_TRACE(("%s: Entered\n", __FUNCTION__)); memset(¶ms, 0, sizeof(wl_iscan_params_t)); memcpy(¶ms.params.bssid, ðer_bcast, ETHER_ADDR_LEN); params.params.bss_type = DOT11_BSSTYPE_ANY; params.params.scan_type = DOT11_SCANTYPE_ACTIVE; params.params.nprobes = htod32(-1); params.params.active_time = htod32(-1); params.params.passive_time = htod32(-1); params.params.home_time = htod32(-1); params.params.channel_num = htod32(0); params.version = htod32(ISCAN_REQ_VERSION); params.action = htod16(action); params.scan_duration = htod16(0); bcm_mkiovar("iscan", (char *)¶ms, sizeof(wl_iscan_params_t), buf, WLC_IOCTL_SMLEN); rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, WLC_IOCTL_SMLEN, TRUE, 0); return rc; }
uint16_t ptp_usb_sendreq (PTPParams* params, PTPContainer* req) { int res; PTPUSBBulkContainer usbreq; unsigned long towrite; Camera *camera = ((PTPData *)params->data)->camera; /* build appropriate USB container */ usbreq.length=htod32(PTP_USB_BULK_REQ_LEN- (sizeof(uint32_t)*(5-req->Nparam))); usbreq.type=htod16(PTP_USB_CONTAINER_COMMAND); usbreq.code=htod16(req->Code); usbreq.trans_id=htod32(req->Transaction_ID); usbreq.payload.params.param1=htod32(req->Param1); usbreq.payload.params.param2=htod32(req->Param2); usbreq.payload.params.param3=htod32(req->Param3); usbreq.payload.params.param4=htod32(req->Param4); usbreq.payload.params.param5=htod32(req->Param5); /* send it to responder */ towrite = PTP_USB_BULK_REQ_LEN-(sizeof(uint32_t)*(5-req->Nparam)); res = gp_port_write (camera->port, (char*)&usbreq, towrite); if (res != towrite) { gp_log (GP_LOG_DEBUG, "ptp2/usb_sendreq", "request code 0x%04x sending req result %d", req->Code,res); return PTP_ERROR_IO; } return PTP_RC_OK; }
int wl_keep_alive_set(struct net_device *dev, char* extra, int total_len) { char buf[256]; const char *str; wl_mkeep_alive_pkt_t mkeep_alive_pkt; wl_mkeep_alive_pkt_t *mkeep_alive_pktp; int buf_len; int str_len; int res = -1; uint period_msec = 0; if (extra == NULL) { DHD_ERROR(("%s: extra is NULL\n", __FUNCTION__)); return -1; } if (sscanf(extra, "%d", &period_msec) != 1) { DHD_ERROR(("%s: sscanf error. check period_msec value\n", __FUNCTION__)); return -EINVAL; } DHD_ERROR(("%s: period_msec is %d\n", __FUNCTION__, period_msec)); memset(&mkeep_alive_pkt, 0, sizeof(wl_mkeep_alive_pkt_t)); str = "mkeep_alive"; str_len = strlen(str); strncpy(buf, str, str_len); buf[ str_len ] = '\0'; mkeep_alive_pktp = (wl_mkeep_alive_pkt_t *) (buf + str_len + 1); mkeep_alive_pkt.period_msec = period_msec; buf_len = str_len + 1; mkeep_alive_pkt.version = htod16(WL_MKEEP_ALIVE_VERSION); mkeep_alive_pkt.length = htod16(WL_MKEEP_ALIVE_FIXED_LEN); /* */ mkeep_alive_pkt.keep_alive_id = 0; mkeep_alive_pkt.len_bytes = 0; buf_len += WL_MKEEP_ALIVE_FIXED_LEN; /* */ memcpy((char *)mkeep_alive_pktp, &mkeep_alive_pkt, WL_MKEEP_ALIVE_FIXED_LEN); if ((res = wldev_ioctl(dev, WLC_SET_VAR, buf, buf_len, TRUE)) < 0) { DHD_ERROR(("%s:keep_alive set failed. res[%d]\n", __FUNCTION__, res)); } else { DHD_ERROR(("%s:keep_alive set ok. res[%d]\n", __FUNCTION__, res)); } return res; }
/* BRCM_UPDATE_E for KEEP_ALIVE */ int wl_keep_alive_set(struct net_device *dev, char* extra, int total_len) { char buf[256]; const char *str; wl_mkeep_alive_pkt_t mkeep_alive_pkt; wl_mkeep_alive_pkt_t *mkeep_alive_pktp; int buf_len; int str_len; int res = -1; uint period_msec = 0; if (extra == NULL) { DHD_ERROR(("%s: extra is NULL\n", __FUNCTION__)); return -1; } if (sscanf(extra, "%d", &period_msec) != 1) { DHD_ERROR(("%s: sscanf error. check period_msec value\n", __FUNCTION__)); return -EINVAL; } DHD_ERROR(("%s: period_msec is %d\n", __FUNCTION__, period_msec)); memset(&mkeep_alive_pkt, 0, sizeof(wl_mkeep_alive_pkt_t)); str = "mkeep_alive"; str_len = strlen(str); strncpy(buf, str, str_len); buf[ str_len ] = '\0'; mkeep_alive_pktp = (wl_mkeep_alive_pkt_t *) (buf + str_len + 1); mkeep_alive_pkt.period_msec = period_msec; buf_len = str_len + 1; mkeep_alive_pkt.version = htod16(WL_MKEEP_ALIVE_VERSION); mkeep_alive_pkt.length = htod16(WL_MKEEP_ALIVE_FIXED_LEN); /* Setup keep alive zero for null packet generation */ mkeep_alive_pkt.keep_alive_id = 0; mkeep_alive_pkt.len_bytes = 0; buf_len += WL_MKEEP_ALIVE_FIXED_LEN; /* Keep-alive attributes are set in local variable (mkeep_alive_pkt), and * then memcpy'ed into buffer (mkeep_alive_pktp) since there is no * guarantee that the buffer is properly aligned. */ memcpy((char *)mkeep_alive_pktp, &mkeep_alive_pkt, WL_MKEEP_ALIVE_FIXED_LEN); if ((res = wldev_ioctl(dev, WLC_SET_VAR, buf, buf_len, TRUE)) < 0) { DHD_ERROR(("%s:keep_alive set failed. res[%d]\n", __FUNCTION__, res)); } else { DHD_ERROR(("%s:keep_alive set ok. res[%d]\n", __FUNCTION__, res)); } return res; }
int wl_wifiaction(void *wl, uint32 packet_id, struct ether_addr *da, uint16 len, uint8 *data) { wl_action_frame_t * action_frame; int err = 0; if (len > ACTION_FRAME_SIZE) return -1; if ((action_frame = (wl_action_frame_t *) malloc(WL_WIFI_ACTION_FRAME_SIZE)) == NULL) { return -1; } /* Add the packet Id */ action_frame->packetId = packet_id; memcpy(&action_frame->da, (char*)da, ETHER_ADDR_LEN); action_frame->len = htod16(len); memcpy(action_frame->data, data, len); err = wlu_var_setbuf(wl, "wifiaction", action_frame, WL_WIFI_ACTION_FRAME_SIZE); free(action_frame); return (err); }
static besl_result_t p2p_scan( void ) { wiced_buffer_t buffer; wl_p2p_scan_t* p2p_scan; /* Begin p2p scan of the "escan" variety */ p2p_scan = wwd_sdpcm_get_iovar_buffer( &buffer, sizeof(wl_p2p_scan_t), IOVAR_STR_P2P_SCAN ); memset( p2p_scan, 0, sizeof(wl_p2p_scan_t) ); /* Fill in the appropriate details of the scan parameters structure */ p2p_scan->type = 'E'; besl_host_random_bytes((uint8_t*)&p2p_scan->escan.sync_id, sizeof(p2p_scan->escan.sync_id)); p2p_scan->escan.version = htod32(ESCAN_REQ_VERSION); p2p_scan->escan.action = htod16(WL_SCAN_ACTION_START); p2p_scan->escan.params.scan_type = (int8_t) WICED_SCAN_TYPE_ACTIVE; p2p_scan->escan.params.bss_type = (int8_t) WICED_BSS_TYPE_INFRASTRUCTURE; p2p_scan->escan.params.nprobes = (int32_t) -1; p2p_scan->escan.params.active_time = (int32_t) -1; p2p_scan->escan.params.passive_time = (int32_t) -1; p2p_scan->escan.params.home_time = (int32_t) -1; p2p_scan->escan.params.channel_num = 0; p2p_scan->escan.params.ssid.SSID_len = sizeof( P2P_WILDCARD_SSID ) - 1; memcpy( p2p_scan->escan.params.ssid.SSID, P2P_WILDCARD_SSID, sizeof( P2P_WILDCARD_SSID ) - 1 ); if ( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WICED_STA_INTERFACE ) != WWD_SUCCESS ) { return BESL_ERROR_SCAN_START_FAIL; } return BESL_SUCCESS; }
int wl_cfgnan_support_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; void *pxtlv; s32 ret = BCME_OK; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } /* * command to test * * wl: wl nan * * wpa_cli: DRIVER NAN_SUPPORT */ /* nan support */ nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_ENABLE); pxtlv = nanioc->data; nanioc->len = htod16(BCM_XTLV_HDR_SIZE + 1); nanioc_size = sizeof(wl_nan_ioc_t) + sizeof(bcm_xtlv_t); ret = wldev_iovar_getbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_SMLEN, &cfg->ioctl_buf_sync); if (unlikely(ret)) { WL_ERR((" nan is not supported, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan is supported \n")); } fail: if (nanioc) { kfree(nanioc); } return ret; }
static int escan(void *wl, uint16 action, uint16 sync_id, int isActive, int numProbes, int activeDwellTime, int passiveDwellTime, int num_channels, uint16 *channels) { int params_size = (WL_SCAN_PARAMS_FIXED_SIZE + OFFSETOF(wl_escan_params_t, params)) + (WL_NUMCHANNELS * sizeof(uint16)); wl_escan_params_t *params; int nssid = 0; int err; params_size += WL_SCAN_PARAMS_SSID_MAX * sizeof(wlc_ssid_t); params = (wl_escan_params_t*)malloc(params_size); if (params == NULL) { return -1; } memset(params, 0, params_size); memcpy(¶ms->params.bssid, ðer_bcast, ETHER_ADDR_LEN); params->params.bss_type = DOT11_BSSTYPE_ANY; params->params.scan_type = isActive ? 0 : WL_SCANFLAGS_PASSIVE; params->params.nprobes = htod32(numProbes); params->params.active_time = htod32(activeDwellTime); params->params.passive_time = htod32(passiveDwellTime); params->params.home_time = htod32(-1); params->params.channel_num = 0; params_size = sizeof(*params); params->version = htod32(ESCAN_REQ_VERSION); params->action = htod16(action); params->sync_id = htod16(sync_id); memcpy(params->params.channel_list, channels, num_channels * sizeof(uint16)); params->params.channel_num = htod32((nssid << WL_SCAN_PARAMS_NSSID_SHIFT) | (num_channels & WL_SCAN_PARAMS_COUNT_MASK)); params_size = (WL_SCAN_PARAMS_FIXED_SIZE + OFFSETOF(wl_escan_params_t, params)) + (num_channels * sizeof(uint16)) + (nssid * sizeof(wlc_ssid_t)); err = wlu_iovar_setbuf(wl, "escan", params, params_size, buf, WLC_IOCTL_MAXLEN); free(params); return err; }
int wl_p2p_scan(void *wl, uint16 sync_id, int isActive, int numProbes, int activeDwellTime, int passiveDwellTime, int num_channels, uint16 *channels) { wl_p2p_scan_t *params = NULL; int params_size = 0; int malloc_size = 0; int nssid = 0; int err = 0; wl_escan_params_t *eparams; malloc_size = sizeof(wl_p2p_scan_t); malloc_size += OFFSETOF(wl_escan_params_t, params) + WL_SCAN_PARAMS_FIXED_SIZE + WL_NUMCHANNELS * sizeof(uint16); malloc_size += WL_SCAN_PARAMS_SSID_MAX * sizeof(wlc_ssid_t); params = (wl_p2p_scan_t *)malloc(malloc_size); if (params == NULL) { fprintf(stderr, "Error allocating %d bytes for scan params\n", malloc_size); return -1; } memset(params, 0, malloc_size); eparams = (wl_escan_params_t *)(params+1); params->type = 'E'; eparams->version = htod32(ESCAN_REQ_VERSION); eparams->action = htod16(WL_SCAN_ACTION_START); eparams->sync_id = sync_id; memcpy(&eparams->params.bssid, ðer_bcast, ETHER_ADDR_LEN); eparams->params.bss_type = DOT11_BSSTYPE_ANY; eparams->params.scan_type = isActive ? 0 : WL_SCANFLAGS_PASSIVE; eparams->params.nprobes = htod32(numProbes); eparams->params.active_time = htod32(activeDwellTime); eparams->params.passive_time = htod32(passiveDwellTime); eparams->params.home_time = htod32(-1); eparams->params.channel_num = 0; memcpy(eparams->params.channel_list, channels, num_channels * sizeof(uint16)); eparams->params.channel_num = htod32((nssid << WL_SCAN_PARAMS_NSSID_SHIFT) | (num_channels & WL_SCAN_PARAMS_COUNT_MASK)); params_size = sizeof(wl_p2p_scan_t) + sizeof(wl_escan_params_t) + WL_SCAN_PARAMS_FIXED_SIZE+ (num_channels * sizeof(uint16)) + (nssid * sizeof(wlc_ssid_t)); err = wlu_iovar_setbuf(wl, "p2p_scan", params, params_size, buf, WLC_IOCTL_MAXLEN); free(params); return err; }
uint16_t ptp_usb_sendreq (PTPParams* params, PTPContainer* req) { int res, towrite, do_retry = TRUE; PTPUSBBulkContainer usbreq; Camera *camera = ((PTPData *)params->data)->camera; GP_LOG_D ("Sending PTP_OC 0x%0x (%s) request...", req->Code, ptp_get_opcode_name(params, req->Code)); /* build appropriate USB container */ usbreq.length=htod32(PTP_USB_BULK_REQ_LEN- (sizeof(uint32_t)*(5-req->Nparam))); usbreq.type=htod16(PTP_USB_CONTAINER_COMMAND); usbreq.code=htod16(req->Code); usbreq.trans_id=htod32(req->Transaction_ID); usbreq.payload.params.param1=htod32(req->Param1); usbreq.payload.params.param2=htod32(req->Param2); usbreq.payload.params.param3=htod32(req->Param3); usbreq.payload.params.param4=htod32(req->Param4); usbreq.payload.params.param5=htod32(req->Param5); /* send it to responder */ towrite = PTP_USB_BULK_REQ_LEN-(sizeof(uint32_t)*(5-req->Nparam)); retry: res = gp_port_write (camera->port, (char*)&usbreq, towrite); if (res != towrite) { if (res < 0) { GP_LOG_E ("PTP_OC 0x%04x sending req failed: %s (%d)", req->Code, gp_port_result_as_string(res), res); if (res == GP_ERROR_IO_WRITE && do_retry) { GP_LOG_D ("Clearing halt on OUT EP and retrying once."); gp_port_usb_clear_halt (camera->port, GP_PORT_USB_ENDPOINT_OUT); do_retry = FALSE; goto retry; } } else GP_LOG_E ("PTP_OC 0x%04x sending req failed: wrote only %d of %d bytes", req->Code, res, towrite); return PTP_ERROR_IO; } return PTP_RC_OK; }
/* * data parsing from ComboScan tlv list */ int wl_iw_parse_data_tlv(char** list_str, void *dst, int dst_size, const char token, int input_size, int *bytes_left) { char* str = *list_str; uint16 short_temp; uint32 int_temp; if ((list_str == NULL) || (*list_str == NULL) ||(bytes_left == NULL) || (*bytes_left < 0)) { DHD_ERROR(("%s error paramters\n", __FUNCTION__)); return -1; } /* Clean all dest bytes */ memset(dst, 0, dst_size); while (*bytes_left > 0) { if (str[0] != token) { DHD_TRACE(("%s NOT Type=%d get=%d left_parse=%d \n", __FUNCTION__, token, str[0], *bytes_left)); return -1; } *bytes_left -= 1; str += 1; if (input_size == 1) { memcpy(dst, str, input_size); } else if (input_size == 2) { memcpy(dst, (char *)htod16(memcpy(&short_temp, str, input_size)), input_size); } else if (input_size == 4) { memcpy(dst, (char *)htod32(memcpy(&int_temp, str, input_size)), input_size); } *bytes_left -= input_size; str += input_size; *list_str = str; return 1; } return 1; }
int wl_actframe(void *wl, int bsscfg_idx, uint32 packet_id, uint32 channel, int32 dwell_time, struct ether_addr *BSSID, struct ether_addr *da, uint16 len, uint8 *data) { wl_action_frame_t * action_frame; wl_af_params_t * af_params; struct ether_addr *bssid; int err = 0; if (len > ACTION_FRAME_SIZE) return -1; if ((af_params = (wl_af_params_t *) malloc(WL_WIFI_AF_PARAMS_SIZE)) == NULL) { return -1; } action_frame = &af_params->action_frame; /* Add the packet Id */ action_frame->packetId = packet_id; memcpy(&action_frame->da, (char*)da, ETHER_ADDR_LEN); /* set default BSSID */ bssid = da; if (BSSID != 0) bssid = BSSID; memcpy(&af_params->BSSID, (char*)bssid, ETHER_ADDR_LEN); action_frame->len = htod16(len); af_params->channel = htod32(channel); af_params->dwell_time = htod32(dwell_time); memcpy(action_frame->data, data, len); if (bsscfg_idx == DEFAULT_BSSCFG_INDEX) err = wlu_var_setbuf(wl, "actframe", af_params, WL_WIFI_AF_PARAMS_SIZE); else err = wlu_bssiovar_setbuf(wl, "actframe", bsscfg_idx, af_params, WL_WIFI_AF_PARAMS_SIZE, buf, WLC_IOCTL_MAXLEN); free(af_params); return (err); }
int wlmSecuritySet(WLM_AUTH_TYPE authType, WLM_AUTH_MODE authMode, WLM_ENCRYPTION encryption, const char *key) { int length = 0; int wpa_auth; int sup_wpa; int primary_key = 0; wl_wsec_key_t wepKey[4]; wsec_pmk_t psk; int wsec; if (encryption != WLM_ENCRYPT_NONE && key == 0) { printf("wlmSecuritySet: invalid key\n"); return FALSE; } if (key) { length = strlen(key); } switch (encryption) { case WLM_ENCRYPT_NONE: wpa_auth = WPA_AUTH_DISABLED; sup_wpa = 0; break; case WLM_ENCRYPT_WEP: { int i; int len = length / 4; wpa_auth = WPA_AUTH_DISABLED; sup_wpa = 0; if (!(length == 40 || length == 104 || length == 128 || length == 256)) { printf("wlmSecuritySet: invalid WEP key length %d" " - expect 40, 104, 128, or 256" " (i.e. 10, 26, 32, or 64 for each of 4 keys)\n", length); return FALSE; } /* convert hex key string to 4 binary keys */ for (i = 0; i < 4; i++) { wl_wsec_key_t *k = &wepKey[i]; const char *data = &key[i * len]; unsigned int j; memset(k, 0, sizeof(*k)); k->index = i; k->len = len / 2; for (j = 0; j < k->len; j++) { char hex[] = "XX"; char *end = NULL; strncpy(hex, &data[j * 2], 2); k->data[j] = (char)strtoul(hex, &end, 16); if (*end != 0) { printf("wlmSecuritySet: invalid WEP key" " - expect hex values\n"); return FALSE; } } switch (k->len) { case 5: k->algo = CRYPTO_ALGO_WEP1; break; case 13: k->algo = CRYPTO_ALGO_WEP128; break; case 16: k->algo = CRYPTO_ALGO_AES_CCM; break; case 32: k->algo = CRYPTO_ALGO_TKIP; break; default: /* invalid */ return FALSE; } k->flags |= WL_PRIMARY_KEY; } break; } case WLM_ENCRYPT_TKIP: case WLM_ENCRYPT_AES: { if (authMode != WLM_WPA_AUTH_PSK && authMode != WLM_WPA2_AUTH_PSK) { printf("wlmSecuritySet: authentication mode must be WPA PSK or WPA2 PSK\n"); return FALSE; } wpa_auth = authMode; sup_wpa = 1; if (length < WSEC_MIN_PSK_LEN || length > WSEC_MAX_PSK_LEN) { printf("wlmSecuritySet: passphrase must be between %d and %d characters\n", WSEC_MIN_PSK_LEN, WSEC_MAX_PSK_LEN); return FALSE; } psk.key_len = length; psk.flags = WSEC_PASSPHRASE; memcpy(psk.key, key, length); break; } case WLM_ENCRYPT_WSEC: case WLM_ENCRYPT_FIPS: default: printf("wlmSecuritySet: encryption not supported\n"); return FALSE; } if (wlu_iovar_setint(irh, "auth", authType)) { printf("wlmSecuritySet: %s\n", wlmLastError()); return FALSE; } if (wlu_iovar_setint(irh, "wpa_auth", wpa_auth)) { printf("wlmSecuritySet: %s\n", wlmLastError()); return FALSE; } if (wlu_iovar_setint(irh, "sup_wpa", sup_wpa)) { printf("wlmSecuritySet: %s\n", wlmLastError()); return FALSE; } if (encryption == WLM_ENCRYPT_WEP) { int i; for (i = 0; i < 4; i++) { wl_wsec_key_t *k = &wepKey[i]; k->index = htod32(k->index); k->len = htod32(k->len); k->algo = htod32(k->algo); k->flags = htod32(k->flags); if (wlu_set(irh, WLC_SET_KEY, k, sizeof(*k))) { printf("wlmSecuritySet: %s\n", wlmLastError()); return FALSE; } } primary_key = htod32(primary_key); if (wlu_set(irh, WLC_SET_KEY_PRIMARY, &primary_key, sizeof(primary_key)) < 0) { printf("wlmSecuritySet: %s\n", wlmLastError()); return FALSE; } } else if (encryption == WLM_ENCRYPT_TKIP || encryption == WLM_ENCRYPT_AES) { psk.key_len = htod16(psk.key_len); psk.flags = htod16(psk.flags); if (wlu_set(irh, WLC_SET_WSEC_PMK, &psk, sizeof(psk))) { printf("wlmSecuritySet: %s\n", wlmLastError()); return FALSE; } } wsec = htod32(encryption); if (wlu_set(irh, WLC_SET_WSEC, &wsec, sizeof(wsec)) < 0) { printf("wlmSecuritySet: %s\n", wlmLastError()); return FALSE; } return TRUE; }
uint16_t ptp_usb_senddata (PTPParams* params, PTPContainer* ptp, uint64_t size, PTPDataHandler *handler ) { uint16_t ret = PTP_RC_OK; int res, wlen, datawlen; PTPUSBBulkContainer usbdata; unsigned long bytes_left_to_transfer, written; Camera *camera = ((PTPData *)params->data)->camera; unsigned char *bytes; int progressid = 0; int usecontext = (size > CONTEXT_BLOCK_SIZE); GPContext *context = ((PTPData *)params->data)->context; /* build appropriate USB container */ usbdata.length = htod32(PTP_USB_BULK_HDR_LEN+size); usbdata.type = htod16(PTP_USB_CONTAINER_DATA); usbdata.code = htod16(ptp->Code); usbdata.trans_id= htod32(ptp->Transaction_ID); if (params->split_header_data) { datawlen = 0; wlen = PTP_USB_BULK_HDR_LEN; } else { unsigned long gotlen; /* For all camera devices. */ datawlen = (size<PTP_USB_BULK_PAYLOAD_LEN_WRITE)?size:PTP_USB_BULK_PAYLOAD_LEN_WRITE; wlen = PTP_USB_BULK_HDR_LEN + datawlen; ret = handler->getfunc(params, handler->priv, datawlen, usbdata.payload.data, &gotlen); if (ret != PTP_RC_OK) return ret; if (gotlen != datawlen) return PTP_RC_GeneralError; } res = gp_port_write (camera->port, (char*)&usbdata, wlen); if (res != wlen) { gp_log (GP_LOG_DEBUG, "ptp2/usb_senddata", "request code 0x%04x sending data error 0x%04x", ptp->Code,ret); return PTP_ERROR_IO; } if (size <= datawlen) { /* nothing more to do */ written = wlen; goto finalize; } if (usecontext) progressid = gp_context_progress_start (context, (size/CONTEXT_BLOCK_SIZE), _("Uploading...")); bytes = malloc (4096); if (!bytes) return PTP_RC_GeneralError; /* if everything OK send the rest */ bytes_left_to_transfer = size-datawlen; ret = PTP_RC_OK; written = 0; while(bytes_left_to_transfer > 0) { unsigned long readlen, toread, oldwritten = written; int res; toread = 4096; if (toread > bytes_left_to_transfer) toread = bytes_left_to_transfer; ret = handler->getfunc (params, handler->priv, toread, bytes, &readlen); if (ret != PTP_RC_OK) break; res = gp_port_write (camera->port, (char*)bytes, readlen); if (res < 0) { ret = PTP_ERROR_IO; break; } bytes_left_to_transfer -= res; written += res; if (usecontext && (oldwritten/CONTEXT_BLOCK_SIZE < written/CONTEXT_BLOCK_SIZE)) gp_context_progress_update (context, progressid, written/CONTEXT_BLOCK_SIZE); #if 0 /* Does not work this way... Hmm. */ if (gp_context_cancel(context) == GP_CONTEXT_FEEDBACK_CANCEL) { ret = ptp_usb_control_cancel_request (params,ptp->Transaction_ID); if (ret == PTP_RC_OK) ret = PTP_ERROR_CANCEL; break; } #endif } if (usecontext) gp_context_progress_stop (context, progressid); free (bytes); finalize: if ((ret == PTP_RC_OK) && ((written % params->maxpacketsize) == 0)) gp_port_write (camera->port, "x", 0); if ((ret!=PTP_RC_OK) && (ret!=PTP_ERROR_CANCEL)) ret = PTP_ERROR_IO; return ret; }
int wl_cfgnan_transmit_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; void *pxtlv; s32 ret = BCME_OK; u16 start, end; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; /* * proceed only if mandatory arguments are present - subscriber id, * publisher id, mac address */ if ((!cmd_data->sub_id) || (!cmd_data->pub_id) || ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) { WL_ERR((" mandatory arguments are not present \n")); return -EINVAL; } nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } /* * command to test * * wl: wl nan trasnmit <sub_id> <pub_id> <mac_addr> -info <hex_string> * * wpa_cli: DRIVER NAN_TRANSMIT SUB_ID=<sub_id> PUB_ID=<pub_id> * MAC_ADDR=<mac_addr> SVC_INFO=<hex_string> */ /* nan transmit */ start = end = NAN_IOCTL_BUF_SIZE; nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_TRANSMIT); pxtlv = nanioc->data; ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_INSTANCE_ID, sizeof(wl_nan_instance_id_t), &cmd_data->sub_id); if (unlikely(ret)) { goto fail; } ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_REQUESTOR_ID, sizeof(wl_nan_instance_id_t), &cmd_data->pub_id); if (unlikely(ret)) { goto fail; } ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_MAC_ADDR, ETHER_ADDR_LEN, &cmd_data->mac_addr.octet); if (unlikely(ret)) { goto fail; } if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) { WL_DBG((" optional svc_info present, pack it \n")); ret = bcm_pack_xtlv_entry_from_hex_string(&pxtlv, &end, WL_NAN_XTLV_SVC_INFO, cmd_data->svc_info.data); if (unlikely(ret)) { goto fail; } } nanioc->len = start - end; nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len; ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan transmit failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan transmit successful \n")); } fail: if (nanioc) { kfree(nanioc); } return ret; }
int wl_cfgnan_cancel_sub_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; struct bcm_tlvbuf *tbuf = NULL; wl_nan_disc_params_t params; s32 ret = BCME_OK; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; /* proceed only if mandatory argument is present - subscriber id */ if (!cmd_data->sub_id) { WL_ERR((" mandatory argument is not present \n")); return -EINVAL; } nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } tbuf = bcm_xtlv_buf_alloc(NULL, BCM_XTLV_HDR_SIZE + sizeof(params)); if (!tbuf) { WL_ERR((" memory allocation failed \n")); ret = -ENOMEM; goto fail; } /* * command to test * * wl: wl nan cancel_subscribe 10 * * wpa_cli: DRIVER NAN_CANCEL_SUBSCRIBE PUB_ID=10 */ bcm_xtlv_put_data(tbuf, WL_NAN_XTLV_INSTANCE_ID, &cmd_data->sub_id, sizeof(wl_nan_instance_id_t)); /* nan cancel subscribe */ nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_CANCEL_SUBSCRIBE); nanioc->len = htod16(bcm_xtlv_buf_len(tbuf)); bcopy(bcm_xtlv_head(tbuf), nanioc->data, bcm_xtlv_buf_len(tbuf)); nanioc_size = sizeof(wl_nan_ioc_t) + bcm_xtlv_buf_len(tbuf); ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan cancel subscribe failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan cancel subscribe successful \n")); } fail: if (tbuf) { bcm_xtlv_buf_free(NULL, tbuf); } if (nanioc) { kfree(nanioc); } return ret; }
int wl_cfgnan_sub_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; struct bcm_tlvbuf *tbuf = NULL; wl_nan_disc_params_t params; s32 ret = BCME_OK; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; /* * proceed only if mandatory arguments are present - subscriber id, * service hash */ if ((!cmd_data->sub_id) || (!cmd_data->svc_hash.data) || (!cmd_data->svc_hash.dlen)) { WL_ERR((" mandatory arguments are not present \n")); return -EINVAL; } nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } tbuf = bcm_xtlv_buf_alloc(NULL, BCM_XTLV_HDR_SIZE + sizeof(params)); if (!tbuf) { WL_ERR((" memory allocation failed \n")); ret = -ENOMEM; goto fail; } /* * command to test * * wl: wl nan subscribe 10 NAN123 * * wpa_cli: DRIVER NAN_SUBSCRIBE SUB_ID=10 SVC_HASH=NAN123 */ /* nan subscribe */ params.period = 1; params.ttl = WL_NAN_TTL_UNTIL_CANCEL; params.flags = 0; params.instance_id = (wl_nan_instance_id_t)cmd_data->sub_id; memcpy((char *)params.svc_hash, cmd_data->svc_hash.data, cmd_data->svc_hash.dlen); bcm_xtlv_put_data(tbuf, WL_NAN_XTLV_SVC_PARAMS, ¶ms, sizeof(params)); nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_SUBSCRIBE); nanioc->len = htod16(bcm_xtlv_buf_len(tbuf)); bcopy(bcm_xtlv_head(tbuf), nanioc->data, bcm_xtlv_buf_len(tbuf)); nanioc_size = sizeof(wl_nan_ioc_t) + bcm_xtlv_buf_len(tbuf); ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan subscribe failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan subscribe successful \n")); } fail: if (tbuf) { bcm_xtlv_buf_free(NULL, tbuf); } if (nanioc) { kfree(nanioc); } return ret; }
int wl_cfgnan_pub_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; struct bcm_tlvbuf *tbuf = NULL; wl_nan_disc_params_t params; s32 ret = BCME_OK; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 tbuf_size = BCM_XTLV_HDR_SIZE + sizeof(params); uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; void *pxtlv; u16 start, end; /* * proceed only if mandatory arguments are present - publisher id, * service hash */ if ((!cmd_data->pub_id) || (!cmd_data->svc_hash.data) || (!cmd_data->svc_hash.dlen)) { WL_ERR((" mandatory arguments are not present \n")); return -EINVAL; } nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } tbuf = bcm_xtlv_buf_alloc(NULL, tbuf_size); if (!tbuf) { WL_ERR((" memory allocation failed \n")); ret = -ENOMEM; goto fail; } /* * command to test * * wl: wl nan publish 10 NAN123 -info <hex_string * wl nan publish 10 NAN123 -info <hex_string -period 1 -ttl 0xffffffff * * wpa_cli: DRIVER NAN_PUBLISH PUB_ID=10 SVC_HASH=NAN123 * SVC_INFO=<hex_string> * DRIVER NAN_PUBLISH PUB_ID=10 SVC_HASH=NAN123 * SVC_INFO=<hex_string> PUB_PR=1 PUB_INT=0xffffffff */ /* nan publish */ start = end = NAN_IOCTL_BUF_SIZE; nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_PUBLISH); pxtlv = nanioc->data; /* disovery parameters */ if (cmd_data->pub_pr) { params.period = cmd_data->pub_pr; } else { params.period = 1; } if (cmd_data->pub_int) { params.ttl = cmd_data->pub_int; } else { params.ttl = WL_NAN_TTL_UNTIL_CANCEL; } params.flags = WL_NAN_PUB_BOTH; params.instance_id = (wl_nan_instance_id_t)cmd_data->pub_id; memcpy((char *)params.svc_hash, cmd_data->svc_hash.data, cmd_data->svc_hash.dlen); ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_SVC_PARAMS, sizeof(wl_nan_disc_params_t), ¶ms); if (unlikely(ret)) { goto fail; } if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) { WL_DBG((" optional svc_info present, pack it \n")); ret = bcm_pack_xtlv_entry_from_hex_string(&pxtlv, &end, WL_NAN_XTLV_SVC_INFO, cmd_data->svc_info.data); if (unlikely(ret)) { goto fail; } } nanioc->len = start - end; nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len; ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan publish failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan publish successful \n")); } fail: if (tbuf) { bcm_xtlv_buf_free(NULL, tbuf); } if (nanioc) { kfree(nanioc); } return ret; }
int wl_cfgnan_status_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; void *pxtlv; char *ptr = cmd; wl_nan_tlv_data_t tlv_data; s32 ret = BCME_OK; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } /* * command to test * * wl: wl nan status * * wpa_cli: DRIVER NAN_STATUS */ /* nan status */ nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_STATUS); pxtlv = nanioc->data; nanioc->len = NAN_IOCTL_BUF_SIZE; nanioc_size = sizeof(wl_nan_ioc_t) + sizeof(bcm_xtlv_t); ret = wldev_iovar_getbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan status failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan status successful \n")); } /* unpack the tlvs */ memset(&tlv_data, 0, sizeof(tlv_data)); nanioc = (wl_nan_ioc_t *)cfg->ioctl_buf; if (g_nan_debug) { prhex(" nanioc->data: ", (uint8 *)nanioc->data, nanioc->len); } bcm_unpack_xtlv_buf(&tlv_data, nanioc->data, nanioc->len, wl_cfgnan_set_vars_cbfn); ptr += sprintf(ptr, CLUS_ID_PREFIX MACF, ETHER_TO_MACF(tlv_data.clus_id)); ptr += sprintf(ptr, " " ROLE_PREFIX"%d", tlv_data.dev_role); ptr += sprintf(ptr, " " AMR_PREFIX); ptr += bcm_format_hex(ptr, tlv_data.amr, NAN_MASTER_RANK_LEN); ptr += sprintf(ptr, " " AMBTT_PREFIX"0x%x", tlv_data.ambtt); ptr += sprintf(ptr, " " HOP_COUNT_PREFIX"%d", tlv_data.hop_count); WL_DBG((" formatted string for userspace: %s, len: %zu \n", cmd, strlen(cmd))); fail: if (nanioc) { kfree(nanioc); } if (tlv_data.svc_info.data) { kfree(tlv_data.svc_info.data); tlv_data.svc_info.data = NULL; tlv_data.svc_info.dlen = 0; } if (tlv_data.vend_info.data) { kfree(tlv_data.vend_info.data); tlv_data.vend_info.data = NULL; tlv_data.vend_info.dlen = 0; } return ret; }
/* Function to execute combined scan */ int dhd_pno_set(dhd_pub_t *dhd, wlc_ssid_t* ssids_local, int nssid, uchar scan_fr) { int err = -1; char iovbuf[128]; int k, i; wl_pfn_param_t pfn_param; wl_pfn_t pfn_element; DHD_TRACE(("%s nssid=%d nchan=%d\n", __FUNCTION__, nssid, scan_fr)); if ((!dhd) && (!ssids_local)) { DHD_ERROR(("%s error exit\n", __FUNCTION__)); err = -1; } /* Check for broadcast ssid */ for (k = 0; k < nssid; k++) { if (!ssids_local[k].SSID_len) { DHD_ERROR(("%d: Broadcast SSID is ilegal for PNO setting\n", k)); return err; } } /* #define PNO_DUMP 1 */ #ifdef PNO_DUMP { int j; for (j = 0; j < nssid; j++) { DHD_ERROR(("%d: scan for %s size =%d\n", j, ssids_local[j].SSID, ssids_local[j].SSID_len)); } } #endif /* PNO_DUMP */ /* clean up everything */ if ((err = dhd_pno_clean(dhd)) < 0) { DHD_ERROR(("%s failed error=%d\n", __FUNCTION__, err)); return err; } memset(&pfn_param, 0, sizeof(pfn_param)); memset(&pfn_element, 0, sizeof(pfn_element)); /* set pfn parameters */ pfn_param.version = htod32(PFN_VERSION); pfn_param.flags = htod16((PFN_LIST_ORDER << SORT_CRITERIA_BIT)); /* set up pno scan fr */ if (scan_fr != 0) pfn_param.scan_freq = htod32(scan_fr); bcm_mkiovar("pfn_set", (char *)&pfn_param, sizeof(pfn_param), iovbuf, sizeof(iovbuf)); dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0); /* set all pfn ssid */ for (i = 0; i < nssid; i++) { pfn_element.bss_type = htod32(DOT11_BSSTYPE_INFRASTRUCTURE); pfn_element.auth = (DOT11_OPEN_SYSTEM); pfn_element.wpa_auth = htod32(WPA_AUTH_PFN_ANY); pfn_element.wsec = htod32(0); pfn_element.infra = htod32(1); memcpy((char *)pfn_element.ssid.SSID, ssids_local[i].SSID, ssids_local[i].SSID_len); pfn_element.ssid.SSID_len = ssids_local[i].SSID_len; if ((err = bcm_mkiovar("pfn_add", (char *)&pfn_element, sizeof(pfn_element), iovbuf, sizeof(iovbuf))) > 0) { if ((err = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0) { DHD_ERROR(("%s failed for i=%d error=%d\n", __FUNCTION__, i, err)); return err; } } else DHD_ERROR(("%s failed err=%d\n", __FUNCTION__, err)); } /* Enable PNO */ /* dhd_pno_enable(dhd, 1); */ return err; }
int wl_cfgnan_stop_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; struct ether_addr cluster_id = ether_null; void *pxtlv; s32 ret = BCME_OK; u16 start, end; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; uint8 nan_enable = FALSE; if (cfg->nan_running == false) { WL_DBG((" nan not running, do nothing \n")); return BCME_OK; } nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } /* * command to test * * wl: wl nan stop * wl nan 0 * * wpa_cli: DRIVER NAN_STOP */ /* nan stop */ start = end = NAN_IOCTL_BUF_SIZE; nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_STOP); pxtlv = nanioc->data; ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_CLUSTER_ID, ETHER_ADDR_LEN, &cluster_id); if (unlikely(ret)) { goto fail; } nanioc->len = start - end; nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len; ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan stop failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan stop successful \n")); } /* nan disable */ memset(nanioc, 0, nanioc_size); start = end = NAN_IOCTL_BUF_SIZE; nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_ENABLE); pxtlv = nanioc->data; ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_ENABLE, sizeof(uint8), &nan_enable); if (unlikely(ret)) { goto fail; } nanioc->len = start - end; nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len; ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan disable failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan disable successful \n")); } fail: if (nanioc) { kfree(nanioc); } return ret; }
int wl_cfgnan_enable_events(struct net_device *ndev, struct bcm_cfg80211 *cfg) { wl_nan_ioc_t *nanioc = NULL; void *pxtlv; u32 event_mask = 0; s32 ret = BCME_OK; u16 start, end; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } ret = wl_add_remove_eventmsg(ndev, WLC_E_NAN, true); if (unlikely(ret)) { WL_ERR((" nan event enable failed, error = %d \n", ret)); goto fail; } if (g_nan_debug) { /* enable all nan events */ event_mask = NAN_EVENT_MASK_ALL; } else { /* enable only selected nan events to avoid unnecessary host wake up */ event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_START); event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_JOIN); event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_DISCOVERY_RESULT); event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_RECEIVE); event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_TERMINATED); event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_STOP); event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_CLEAR_BIT); event_mask = htod32(event_mask); } start = end = NAN_IOCTL_BUF_SIZE; nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_EVENT_MASK); pxtlv = nanioc->data; ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_EVENT_MASK, sizeof(uint32), &event_mask); if (unlikely(ret)) { goto fail; } nanioc->len = start - end; nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len; ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan event selective enable failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan event selective enable successful \n")); } ret = wl_add_remove_eventmsg(ndev, WLC_E_PROXD, true); if (unlikely(ret)) { WL_ERR((" proxd event enable failed, error = %d \n", ret)); goto fail; } fail: if (nanioc) { kfree(nanioc); } return ret; }
int wl_cfgnan_set_config_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data) { wl_nan_ioc_t *nanioc = NULL; void *pxtlv; s32 ret = BCME_OK; u16 start, end; u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL; uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE; nanioc = kzalloc(nanioc_size, kflags); if (!nanioc) { WL_ERR((" memory allocation failed \n")); return -ENOMEM; } /* * command to test * * wl: wl nan <attr> <value> (wl nan role 1) * * wpa_cli: DRIVER NAN_CONFIG_SET ATTR=<attr> <value>...<value> * * wpa_cli: DRIVER NAN_SET_CONFIG ATTR=ATTR_ROLE ROLE=1 */ /* nan set config */ start = end = NAN_IOCTL_BUF_SIZE; nanioc->version = htod16(WL_NAN_IOCTL_VERSION); nanioc->id = htod16(WL_NAN_CMD_ATTR); pxtlv = nanioc->data; switch (cmd_data->attr.type) { case WL_NAN_XTLV_ROLE: ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_ROLE, sizeof(u32), &cmd_data->role); break; case WL_NAN_XTLV_MASTER_PREF: ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_MASTER_PREF, sizeof(u16), &cmd_data->master_pref); break; case WL_NAN_XTLV_DW_LEN: ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_DW_LEN, sizeof(u16), &cmd_data->dw_len); break; case WL_NAN_XTLV_CLUSTER_ID: case WL_NAN_XTLV_IF_ADDR: case WL_NAN_XTLV_BCN_INTERVAL: case WL_NAN_XTLV_MAC_CHANSPEC: case WL_NAN_XTLV_MAC_TXRATE: default: ret = -EINVAL; break; } if (unlikely(ret)) { WL_ERR((" unsupported attribute, attr = %s (%d) \n", cmd_data->attr.name, cmd_data->attr.type)); goto fail; } nanioc->len = start - end; nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len; ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL); if (unlikely(ret)) { WL_ERR((" nan set config failed, error = %d \n", ret)); goto fail; } else { WL_DBG((" nan set config successful \n")); } fail: if (nanioc) { kfree(nanioc); } return ret; }