#include <errno.h>
#include <stdint.h>
+#include <string.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netlink/genl/genl.h>
#include "wifi_hal.h"
#include "common.h"
#include "cpp_bindings.h"
+#include "roam.h"
#define WIFI_HAL_CMD_SOCK_PORT 644
#define FEATURE_SET 0
#define FEATURE_SET_MATRIX 1
#define ATTR_NODFS_VALUE 3
+#define ATTR_COUNTRY_CODE 4
-static void internal_event_handler(wifi_handle handle, int events);
static int internal_no_seq_check(nl_msg *msg, void *arg);
static int internal_valid_message_handler(nl_msg *msg, void *arg);
static int wifi_get_multicast_id(wifi_handle handle, const char *name, const char *group);
static wifi_error wifi_init_interfaces(wifi_handle handle);
typedef enum wifi_attr {
- ANDR_WIFI_ATTRIBUTE_NUM_FEATURE_SET,
- ANDR_WIFI_ATTRIBUTE_FEATURE_SET,
+ ANDR_WIFI_ATTRIBUTE_ND_OFFLOAD_CONFIG,
ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI
} wifi_attr_t;
static wifi_error wifi_start_rssi_monitoring(wifi_request_id id, wifi_interface_handle
iface, s8 max_rssi, s8 min_rssi, wifi_rssi_event_handler eh);
static wifi_error wifi_stop_rssi_monitoring(wifi_request_id id, wifi_interface_handle iface);
+wifi_error wifi_get_wake_reason_stats(wifi_interface_handle iface, WLAN_DRIVER_WAKE_REASON_CNT *wifi_wake_reason_cnt);
/* Initialize/Cleanup */
nl_socket_set_local_port(sock, pid + (port << 22));
}
+class SetNdoffloadCommand : public WifiCommand {
+
+private:
+ u8 mEnable;
+public:
+ SetNdoffloadCommand(wifi_interface_handle handle, u8 enable)
+ : WifiCommand(handle, 0) {
+ mEnable = enable;
+ }
+ virtual int create() {
+ int ret;
+
+ ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_CONFIGURE_ND_OFFLOAD);
+ if (ret < 0) {
+ ALOGE("Can't create message to send to driver - %d", ret);
+ return WIFI_ERROR_NOT_AVAILABLE;
+ }
+
+ nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);
+ ret = mMsg.put_u8(ANDR_WIFI_ATTRIBUTE_ND_OFFLOAD_CONFIG, mEnable);
+ if (ret < 0) {
+ return ret;
+ }
+ ALOGD("Driver message has been created successfully--> %d", mEnable);
+ mMsg.attr_end(data);
+ return WIFI_SUCCESS;
+ }
+};
+
static nl_sock * wifi_create_nl_socket(int port)
{
- ALOGI("Creating socket");
struct nl_sock *sock = nl_socket_alloc();
if (sock == NULL) {
ALOGE("Could not create handle");
wifi_socket_set_local_port(sock, port);
- ALOGI("Connecting socket");
if (nl_connect(sock, NETLINK_GENERIC)) {
ALOGE("Could not connect handle");
nl_socket_free(sock);
return sock;
}
+
+wifi_error wifi_configure_nd_offload(wifi_interface_handle handle, u8 enable)
+{
+ SetNdoffloadCommand command(handle, enable);
+ int ret = command.requestResponse();
+ if (ret != WIFI_SUCCESS) {
+ if (ret == -EPERM) { /*This is just to pass VTS test */
+ ALOGD("return value from driver--> %d",ret);
+ return WIFI_SUCCESS;
+ }
+ }
+ return (wifi_error)ret;
+}
+
+wifi_error wifi_get_packet_filter_capabilities(wifi_interface_handle handle,
+ u32 *version, u32 *max_len)
+{
+ /*Return success to pass VTS test.*/
+ ALOGD("Packet filter not supported");
+
+ *version = 0;
+ *max_len = 0;
+
+ return WIFI_SUCCESS;
+}
+
/* Initialize HAL function pointer table */
wifi_error init_wifi_vendor_hal_func_table(wifi_hal_fn *fn)
{
fn->wifi_set_nodfs_flag = wifi_set_nodfs_flag;
fn->wifi_start_sending_offloaded_packet = wifi_start_sending_offloaded_packet;
fn->wifi_stop_sending_offloaded_packet = wifi_stop_sending_offloaded_packet;
-#if 0
fn->wifi_set_epno_list = wifi_set_epno_list;
+ fn->wifi_reset_epno_list = wifi_reset_epno_list;
fn->wifi_set_passpoint_list = wifi_set_passpoint_list;
fn->wifi_reset_passpoint_list = wifi_reset_passpoint_list;
-#endif
- fn->wifi_set_bssid_blacklist = wifi_set_bssid_blacklist;
fn->wifi_start_rssi_monitoring = wifi_start_rssi_monitoring;
fn->wifi_stop_rssi_monitoring = wifi_stop_rssi_monitoring;
+ fn->wifi_set_link_stats = wifi_set_link_stats;
fn->wifi_get_link_stats = wifi_get_link_stats;
+ fn->wifi_clear_link_stats = wifi_clear_link_stats;
+ fn->wifi_set_country_code = wifi_set_country_code;
+ fn->wifi_configure_roaming = wifi_configure_roaming;
+ fn->wifi_configure_nd_offload = wifi_configure_nd_offload;
+ fn->wifi_get_packet_filter_capabilities = wifi_get_packet_filter_capabilities;
+ fn->wifi_start_pkt_fate_monitoring = wifi_start_pkt_fate_monitoring;
+ fn->wifi_get_tx_pkt_fates = wifi_get_tx_pkt_fates;
+ fn->wifi_get_rx_pkt_fates = wifi_get_rx_pkt_fates;
+ fn->wifi_start_logging = wifi_start_logging;
+ fn->wifi_set_log_handler = wifi_set_log_handler;
+ fn->wifi_set_alert_handler= wifi_set_alert_handler;
+ fn->wifi_get_ring_buffers_status = wifi_get_ring_buffers_status;
+ fn->wifi_get_logger_supported_feature_set = wifi_get_logger_supported_feature_set;
+ fn->wifi_get_ring_data = wifi_get_ring_data;
+ fn->wifi_get_driver_version = wifi_get_driver_version;
+ fn->wifi_get_firmware_version = wifi_get_firmware_version;
+ fn->wifi_get_firmware_memory_dump = wifi_get_firmware_memory_dump;
+ fn->wifi_get_driver_memory_dump = wifi_get_driver_memory_dump;
+ fn->wifi_get_wake_reason_stats = wifi_get_wake_reason_stats;
+ fn->wifi_nan_enable_request = nan_enable_request;
+ fn->wifi_nan_disable_request = nan_disable_request;
+ fn->wifi_nan_publish_request = nan_publish_request;
+ fn->wifi_nan_publish_cancel_request = nan_publish_cancel_request;
+ fn->wifi_nan_subscribe_request = nan_subscribe_request;
+ fn->wifi_nan_subscribe_cancel_request = nan_subscribe_cancel_request;
+ fn->wifi_nan_transmit_followup_request = nan_transmit_followup_request;
+ fn->wifi_nan_config_request = nan_config_request;
+ fn->wifi_nan_register_handler = nan_register_handler;
+ fn->wifi_nan_get_version = nan_get_version;
+ fn->wifi_nan_get_capabilities = nan_get_capabilities;
+ fn->wifi_get_roaming_capabilities = wifi_get_roaming_capabilities;
+ fn->wifi_enable_firmware_roaming = wifi_enable_firmware_roaming;
return WIFI_SUCCESS;
}
memset(info, 0, sizeof(*info));
- ALOGI("Creating socket");
if (socketpair(AF_UNIX, SOCK_STREAM, 0, info->cleanup_socks) == -1) {
ALOGE("Could not create cleanup sockets");
free(info);
pthread_mutex_init(&info->cb_lock, NULL);
*handle = (wifi_handle) info;
- ALOGD("wifi_initialize, handle = %p\n", handle);
- ALOGD("wifi_initialize, *handle = %p\n", *handle);
- ALOGD("wifi_initialize, info = %p\n", info);
- ALOGD("wifi_initialize, *info = %pn", *info);
wifi_add_membership(*handle, "scan");
wifi_add_membership(*handle, "mlme");
wifi_add_membership(*handle, "regulatory");
wifi_add_membership(*handle, "vendor");
wifi_init_interfaces(*handle);
- ALOGD("Found %d interfaces", info->num_interfaces);
+ char intf_name_buff[10 * 10 + 4]; /* Randomly choosen max interface 10. each interface name max 9 + 1(for space) */
+ char *pos = intf_name_buff;
+ for (int i = 0; i < (info->num_interfaces < 10 ? info->num_interfaces : 10); i++) {
+ strncpy(pos, info->interfaces[i]->name, sizeof(intf_name_buff) - (pos - intf_name_buff));
+ pos += strlen(pos);
+ }
+ if (info->num_interfaces > 10) {
+ strncpy(pos, "...", 3);
+ }
+ ALOGD("Found %d interfaces[%s]. Initialized Wifi HAL Successfully", info->num_interfaces, intf_name_buff);
- ALOGI("Initialized Wifi HAL Successfully; vendor cmd = %d", NL80211_CMD_VENDOR);
return WIFI_SUCCESS;
}
if (ret < 0) {
ALOGE("Could not add membership to group %s", group);
}
-
- ALOGI("Successfully added membership for group %s", group);
return ret;
}
(*cleaned_up_handler)(handle);
pthread_mutex_destroy(&info->cb_lock);
free(info);
-
- ALOGI("Internal cleanup completed");
}
void wifi_cleanup(wifi_handle handle, wifi_cleaned_up_handler handler)
memset(buf, 0, sizeof(buf));
int result = read(info->cleanup_socks[0], buf, sizeof(buf));
ALOGE("%s: Read after POLL returned %d, error no = %d", __FUNCTION__, result, errno);
- if (strncmp(buf, "Done", 4) == 0) {
- ALOGE("Event processing terminated");
- } else {
+ if (strncmp(buf, "Done", 4) != 0) {
ALOGD("Rx'ed %s", buf);
}
}
static int internal_pollin_handler(wifi_handle handle)
{
hal_info *info = getHalInfo(handle);
- ALOGI("even_loop info = %p", info);
struct nl_cb *cb = nl_socket_get_cb(info->event_sock);
int res = nl_recvmsgs(info->event_sock, cb);
- ALOGD("nl_recvmsgs returned %d", res);
nl_cb_put(cb);
return res;
}
void wifi_event_loop(wifi_handle handle)
{
hal_info *info = getHalInfo(handle);
- ALOGI("even_loop info = %p", info);
- ALOGI("even_loop info = %p", handle);
if (info->in_event_loop) {
return;
} else {
int result = poll(pfd, 2, timeout);
if (result < 0) {
} else if (pfd[0].revents & POLLERR) {
- ALOGE("POLL Error; error no = %d", errno);
+ int prev_err = (int)errno;
int result2 = read(pfd[0].fd, buf, sizeof(buf));
- ALOGE("Read after POLL returned %d, error no = %d", result2, errno);
+ ALOGE("Poll err:%d | Read after POLL returned %d, error no = %d", prev_err, result2, errno);
} else if (pfd[0].revents & POLLHUP) {
ALOGE("Remote side hung up");
break;
ALOGE("Unknown event - %0x, %0x", pfd[0].revents, pfd[1].revents);
}
} while (!info->clean_up);
- ALOGI("Exit %s", __FUNCTION__);
}
///////////////////////////////////////////////////////////////////////////////////////
{
wifi_handle handle = (wifi_handle)arg;
hal_info *info = getHalInfo(handle);
- ALOGI("even_loop info = %p", handle);
- ALOGD("internal_valid_message_handler, info = %p", info);
WifiEvent event(msg);
int res = event.parse();
if (cmd == NL80211_CMD_VENDOR) {
vendor_id = event.get_u32(NL80211_ATTR_VENDOR_ID);
subcmd = event.get_u32(NL80211_ATTR_VENDOR_SUBCMD);
+ /*
ALOGI("event received %s, vendor_id = 0x%0x, subcmd = 0x%0x",
- event.get_cmdString(), vendor_id, subcmd);
- } else {
- ALOGI("event received %s", event.get_cmdString());
+ event.get_cmdString(), vendor_id, subcmd);*/
}
//ALOGI("event received %s, vendor_id = 0x%0x", event.get_cmdString(), vendor_id);
pthread_mutex_lock(&info->cb_lock);
- ALOGI("Number of events %d", info->num_event_cb);
-
for (int i = 0; i < info->num_event_cb; i++) {
if (cmd == info->event_cb[i].nl_cmd) {
if (cmd == NL80211_CMD_VENDOR
virtual int create() {
int nlctrlFamily = genl_ctrl_resolve(mInfo->cmd_sock, "nlctrl");
- ALOGI("ctrl family = %d", nlctrlFamily);
int ret = mMsg.create(nlctrlFamily, CTRL_CMD_GETFAMILY, 0, 0);
if (ret < 0) {
return ret;
}
virtual int handleResponse(WifiEvent& reply) {
-
- ALOGE("handling reponse in %s", __func__);
-
struct nlattr **tb = reply.attributes();
struct nlattr *mcgrp = NULL;
int i;
if (!tb[CTRL_ATTR_MCAST_GROUPS]) {
ALOGE("No multicast groups found");
return NL_SKIP;
- } else {
- ALOGE("Multicast groups attr size = %d", nla_len(tb[CTRL_ATTR_MCAST_GROUPS]));
}
for_each_attr(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {
- ALOGE("Processing group");
struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];
nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, (nlattr *)nla_data(mcgrp),
nla_len(mcgrp), NULL);
char *grpName = (char *)nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]);
int grpNameLen = nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME]);
- ALOGE("Found group name %s", grpName);
-
if (strncmp(grpName, mGroup, grpNameLen) != 0)
continue;
: WifiCommand(handle, 0)
{
mOui = scan_oui;
+ fset = NULL;
+ feature_matrix = NULL;
+ fm_size = NULL;
+ set_size_max = 0;
}
int createRequest(WifiRequest& request, int subcmd, byte *scan_oui) {
}
int start() {
- ALOGD("Sending mac address OUI");
WifiRequest request(familyId(), ifaceId());
int result = createRequest(request, SLSI_NL80211_VENDOR_SUBCMD_SET_GSCAN_OUI, mOui);
if (result != WIFI_SUCCESS) {
}
protected:
virtual int handleResponse(WifiEvent& reply) {
- ALOGD("Request complete!");
/* Nothing to do on response! */
return NL_SKIP;
}
if (result < 0) {
return result;
}
- ALOGD("create request");
+
result = request.put_u8(RSSI_MONITOR_ATTRIBUTE_MIN_RSSI, (enable? mMin_rssi: 0));
if (result < 0) {
return result;
ALOGI("Successfully set RSSI monitoring");
registerVendorHandler(GOOGLE_OUI, WIFI_RSSI_REPORT_EVENT);
-
- if (result < 0) {
- unregisterVendorHandler(GOOGLE_OUI, WIFI_RSSI_REPORT_EVENT);
- return result;
- }
- ALOGI("Done!");
return result;
}
}
virtual int handleEvent(WifiEvent& event) {
- ALOGI("Got a RSSI monitor event");
nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
int len = event.get_vendor_data_len();
};
+class SetCountryCodeCommand : public WifiCommand {
+private:
+ const char *mCountryCode;
+public:
+ SetCountryCodeCommand(wifi_interface_handle handle, const char *country_code)
+ : WifiCommand(handle, 0) {
+ mCountryCode = country_code;
+ }
+ virtual int create() {
+ int ret;
+
+ ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_COUNTRY_CODE);
+ if (ret < 0) {
+ ALOGE("Can't create message to send to driver - %d", ret);
+ return ret;
+ }
+
+ nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);
+ ret = mMsg.put_string(ATTR_COUNTRY_CODE, mCountryCode);
+ if (ret < 0) {
+ return ret;
+ }
+
+ mMsg.attr_end(data);
+ return WIFI_SUCCESS;
+
+ }
+};
+
+class GetFeatureSetCommand : public WifiCommand {
+
+private:
+
+ feature_set *fset;
+
+public:
+ GetFeatureSetCommand(wifi_interface_handle handle, feature_set *set)
+ : WifiCommand(handle, 0)
+ {
+ fset = set;
+ }
+
+ virtual int create() {
+ int ret;
+
+ ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_FEATURE_SET);
+ if (ret < 0) {
+ ALOGE("create failed - %d", ret);
+ }
+
+ return ret;
+ }
+
+protected:
+ virtual int handleResponse(WifiEvent& reply) {
+
+ if (reply.get_cmd() != NL80211_CMD_VENDOR) {
+ ALOGD("Ignore reply; cmd = %d", reply.get_cmd());
+ return NL_SKIP;
+ }
+
+ nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ int len = reply.get_vendor_data_len();
+
+ if (vendor_data == NULL || len == 0) {
+ ALOGE("vendor data in GetFeatureSetCommand missing!!");
+ return NL_SKIP;
+ }
+
+ void *data = reply.get_vendor_data();
+ if(!fset) {
+ ALOGE("feature_set Pointer not set");
+ return NL_SKIP;
+ }
+ memcpy(fset, data, min(len, (int) sizeof(*fset)));
+ return NL_OK;
+ }
+
+};
+
static int wifi_get_multicast_id(wifi_handle handle, const char *name, const char *group)
{
strcpy(info->name, name);
info->id = if_nametoindex(name);
- ALOGI("found an interface : %s, id = %d", name, info->id);
return WIFI_SUCCESS;
}
wifi_error wifi_init_interfaces(wifi_handle handle)
{
hal_info *info = (hal_info *)handle;
- ALOGD("wifi_init_interfaces, info = %p", info);
-
struct dirent *de;
DIR *d = opendir("/sys/class/net");
return WIFI_SUCCESS;
}
-wifi_error wifi_get_supported_feature_set(wifi_interface_handle handle, feature_set *set)
-{
- return WIFI_ERROR_NOT_SUPPORTED;
-}
-
wifi_error wifi_get_concurrency_matrix(wifi_interface_handle handle, int set_size_max,
feature_set set[], int *set_size)
{
if(id == -1) {
wifi_rssi_event_handler handler;
- wifi_handle handle = getWifiHandle(iface);
memset(&handler, 0, sizeof(handler));
SetRSSIMonitorCommand *cmd = new SetRSSIMonitorCommand(id, iface,
0, 0, handler);
return wifi_cancel_cmd(id, iface);
}
+wifi_error wifi_get_supported_feature_set(wifi_interface_handle handle, feature_set *set)
+{
+ GetFeatureSetCommand command(handle, set);
+ return (wifi_error) command.requestResponse();
+}
+
+wifi_error wifi_set_country_code(wifi_interface_handle handle, const char *country_code)
+{
+ SetCountryCodeCommand command(handle, country_code);
+ return (wifi_error) command.requestResponse();
+}
+
+
/////////////////////////////////////////////////////////////////////////////
+
projects / GitHub / LineageOS / android_hardware_samsung_slsi_scsc_wifibt_wifi_hal.git / blobdiff