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;
}
