5 #include <sys/socket.h>
6 #include <netlink/genl/genl.h>
7 #include <netlink/genl/family.h>
8 #include <netlink/genl/ctrl.h>
9 #include <linux/rtnetlink.h>
10 #include <netpacket/packet.h>
11 #include <linux/filter.h>
12 #include <linux/errqueue.h>
14 #include <linux/pkt_sched.h>
15 #include <netlink/object-api.h>
16 #include <netlink/netlink.h>
17 #include <netlink/socket.h>
18 #include <netlink/attr.h>
19 #include <netlink/handlers.h>
20 #include <netlink/msg.h>
27 #define LOG_TAG "WifiHAL"
29 #include <utils/Log.h>
32 #include "cpp_bindings.h"
36 #define WIFI_HAL_CMD_SOCK_PORT 644
37 #define WIFI_HAL_EVENT_SOCK_PORT 645
40 #define FEATURE_SET_MATRIX 1
41 #define ATTR_NODFS_VALUE 3
42 #define ATTR_COUNTRY_CODE 4
44 static int internal_no_seq_check(nl_msg
*msg
, void *arg
);
45 static int internal_valid_message_handler(nl_msg
*msg
, void *arg
);
46 static int wifi_get_multicast_id(wifi_handle handle
, const char *name
, const char *group
);
47 static int wifi_add_membership(wifi_handle handle
, const char *group
);
48 static wifi_error
wifi_init_interfaces(wifi_handle handle
);
50 typedef enum wifi_attr
{
51 ANDR_WIFI_ATTRIBUTE_ND_OFFLOAD_CONFIG
,
52 ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI
55 enum wifi_rssi_monitor_attr
{
56 RSSI_MONITOR_ATTRIBUTE_MAX_RSSI
,
57 RSSI_MONITOR_ATTRIBUTE_MIN_RSSI
,
58 RSSI_MONITOR_ATTRIBUTE_START
,
61 static wifi_error
wifi_start_rssi_monitoring(wifi_request_id id
, wifi_interface_handle
62 iface
, s8 max_rssi
, s8 min_rssi
, wifi_rssi_event_handler eh
);
63 static wifi_error
wifi_stop_rssi_monitoring(wifi_request_id id
, wifi_interface_handle iface
);
64 wifi_error
wifi_get_wake_reason_stats(wifi_interface_handle iface
, WLAN_DRIVER_WAKE_REASON_CNT
*wifi_wake_reason_cnt
);
66 /* Initialize/Cleanup */
68 void wifi_socket_set_local_port(struct nl_sock
*sock
, uint32_t port
)
70 uint32_t pid
= getpid() & 0x3FFFFF;
71 nl_socket_set_local_port(sock
, pid
+ (port
<< 22));
74 class SetNdoffloadCommand
: public WifiCommand
{
79 SetNdoffloadCommand(wifi_interface_handle handle
, u8 enable
)
80 : WifiCommand(handle
, 0) {
83 virtual int create() {
86 ret
= mMsg
.create(GOOGLE_OUI
, SLSI_NL80211_VENDOR_SUBCMD_CONFIGURE_ND_OFFLOAD
);
88 ALOGE("Can't create message to send to driver - %d", ret
);
89 return WIFI_ERROR_NOT_AVAILABLE
;
92 nlattr
*data
= mMsg
.attr_start(NL80211_ATTR_VENDOR_DATA
);
93 ret
= mMsg
.put_u8(ANDR_WIFI_ATTRIBUTE_ND_OFFLOAD_CONFIG
, mEnable
);
97 ALOGD("Driver message has been created successfully--> %d", mEnable
);
103 static nl_sock
* wifi_create_nl_socket(int port
)
105 struct nl_sock
*sock
= nl_socket_alloc();
107 ALOGE("Could not create handle");
111 wifi_socket_set_local_port(sock
, port
);
113 if (nl_connect(sock
, NETLINK_GENERIC
)) {
114 ALOGE("Could not connect handle");
115 nl_socket_free(sock
);
123 wifi_error
wifi_configure_nd_offload(wifi_interface_handle handle
, u8 enable
)
125 SetNdoffloadCommand
command(handle
, enable
);
126 int ret
= command
.requestResponse();
127 if (ret
!= WIFI_SUCCESS
) {
128 if (ret
== -EPERM
) { /*This is just to pass VTS test */
129 ALOGD("return value from driver--> %d",ret
);
133 return (wifi_error
)ret
;
136 wifi_error
wifi_get_packet_filter_capabilities(wifi_interface_handle handle
,
137 u32
*version
, u32
*max_len
)
139 /*Return success to pass VTS test.*/
140 ALOGD("Packet filter not supported");
148 /* Initialize HAL function pointer table */
149 wifi_error
init_wifi_vendor_hal_func_table(wifi_hal_fn
*fn
)
152 return WIFI_ERROR_UNKNOWN
;
154 fn
->wifi_initialize
= wifi_initialize
;
155 fn
->wifi_cleanup
= wifi_cleanup
;
156 fn
->wifi_event_loop
= wifi_event_loop
;
157 fn
->wifi_get_supported_feature_set
= wifi_get_supported_feature_set
;
158 fn
->wifi_get_concurrency_matrix
= wifi_get_concurrency_matrix
;
159 fn
->wifi_set_scanning_mac_oui
= wifi_set_scanning_mac_oui
;
160 fn
->wifi_get_ifaces
= wifi_get_ifaces
;
161 fn
->wifi_get_iface_name
= wifi_get_iface_name
;
162 fn
->wifi_start_gscan
= wifi_start_gscan
;
163 fn
->wifi_stop_gscan
= wifi_stop_gscan
;
164 fn
->wifi_get_cached_gscan_results
= wifi_get_cached_gscan_results
;
165 fn
->wifi_set_bssid_hotlist
= wifi_set_bssid_hotlist
;
166 fn
->wifi_reset_bssid_hotlist
= wifi_reset_bssid_hotlist
;
167 fn
->wifi_set_significant_change_handler
= wifi_set_significant_change_handler
;
168 fn
->wifi_reset_significant_change_handler
= wifi_reset_significant_change_handler
;
169 fn
->wifi_get_gscan_capabilities
= wifi_get_gscan_capabilities
;
170 fn
->wifi_get_valid_channels
= wifi_get_valid_channels
;
171 fn
->wifi_rtt_range_request
= wifi_rtt_range_request
;
172 fn
->wifi_rtt_range_cancel
= wifi_rtt_range_cancel
;
173 fn
->wifi_get_rtt_capabilities
= wifi_get_rtt_capabilities
;
174 fn
->wifi_set_nodfs_flag
= wifi_set_nodfs_flag
;
175 //fn->wifi_start_sending_offloaded_packet = wifi_start_sending_offloaded_packet;
176 fn
->wifi_stop_sending_offloaded_packet
= wifi_stop_sending_offloaded_packet
;
177 fn
->wifi_set_epno_list
= wifi_set_epno_list
;
178 fn
->wifi_reset_epno_list
= wifi_reset_epno_list
;
179 fn
->wifi_set_passpoint_list
= wifi_set_passpoint_list
;
180 fn
->wifi_reset_passpoint_list
= wifi_reset_passpoint_list
;
181 fn
->wifi_start_rssi_monitoring
= wifi_start_rssi_monitoring
;
182 fn
->wifi_stop_rssi_monitoring
= wifi_stop_rssi_monitoring
;
183 fn
->wifi_set_link_stats
= wifi_set_link_stats
;
184 fn
->wifi_get_link_stats
= wifi_get_link_stats
;
185 fn
->wifi_clear_link_stats
= wifi_clear_link_stats
;
186 fn
->wifi_set_country_code
= wifi_set_country_code
;
187 fn
->wifi_configure_roaming
= wifi_configure_roaming
;
188 fn
->wifi_configure_nd_offload
= wifi_configure_nd_offload
;
189 fn
->wifi_get_packet_filter_capabilities
= wifi_get_packet_filter_capabilities
;
190 fn
->wifi_start_pkt_fate_monitoring
= wifi_start_pkt_fate_monitoring
;
191 fn
->wifi_get_tx_pkt_fates
= wifi_get_tx_pkt_fates
;
192 fn
->wifi_get_rx_pkt_fates
= wifi_get_rx_pkt_fates
;
193 fn
->wifi_start_logging
= wifi_start_logging
;
194 fn
->wifi_set_log_handler
= wifi_set_log_handler
;
195 fn
->wifi_set_alert_handler
= wifi_set_alert_handler
;
196 fn
->wifi_get_ring_buffers_status
= wifi_get_ring_buffers_status
;
197 fn
->wifi_get_logger_supported_feature_set
= wifi_get_logger_supported_feature_set
;
198 fn
->wifi_get_ring_data
= wifi_get_ring_data
;
199 fn
->wifi_get_driver_version
= wifi_get_driver_version
;
200 fn
->wifi_get_firmware_version
= wifi_get_firmware_version
;
201 fn
->wifi_get_firmware_memory_dump
= wifi_get_firmware_memory_dump
;
202 fn
->wifi_get_driver_memory_dump
= wifi_get_driver_memory_dump
;
203 fn
->wifi_get_wake_reason_stats
= wifi_get_wake_reason_stats
;
204 fn
->wifi_nan_enable_request
= nan_enable_request
;
205 fn
->wifi_nan_disable_request
= nan_disable_request
;
206 fn
->wifi_nan_publish_request
= nan_publish_request
;
207 fn
->wifi_nan_publish_cancel_request
= nan_publish_cancel_request
;
208 fn
->wifi_nan_subscribe_request
= nan_subscribe_request
;
209 fn
->wifi_nan_subscribe_cancel_request
= nan_subscribe_cancel_request
;
210 fn
->wifi_nan_transmit_followup_request
= nan_transmit_followup_request
;
211 fn
->wifi_nan_config_request
= nan_config_request
;
212 fn
->wifi_nan_register_handler
= nan_register_handler
;
213 fn
->wifi_nan_get_version
= nan_get_version
;
214 fn
->wifi_nan_get_capabilities
= nan_get_capabilities
;
215 fn
->wifi_get_roaming_capabilities
= wifi_get_roaming_capabilities
;
216 fn
->wifi_enable_firmware_roaming
= wifi_enable_firmware_roaming
;
221 wifi_error
wifi_initialize(wifi_handle
*handle
)
225 ALOGI("Initializing wifi");
226 hal_info
*info
= (hal_info
*)malloc(sizeof(hal_info
));
228 ALOGE("Could not allocate hal_info");
229 return WIFI_ERROR_UNKNOWN
;
232 memset(info
, 0, sizeof(*info
));
234 if (socketpair(AF_UNIX
, SOCK_STREAM
, 0, info
->cleanup_socks
) == -1) {
235 ALOGE("Could not create cleanup sockets");
237 return WIFI_ERROR_UNKNOWN
;
240 struct nl_sock
*cmd_sock
= wifi_create_nl_socket(WIFI_HAL_CMD_SOCK_PORT
);
241 if (cmd_sock
== NULL
) {
242 ALOGE("Could not create handle");
244 return WIFI_ERROR_UNKNOWN
;
247 struct nl_sock
*event_sock
= wifi_create_nl_socket(WIFI_HAL_EVENT_SOCK_PORT
);
248 if (event_sock
== NULL
) {
249 ALOGE("Could not create handle");
250 nl_socket_free(cmd_sock
);
252 return WIFI_ERROR_UNKNOWN
;
255 struct nl_cb
*cb
= nl_socket_get_cb(event_sock
);
257 ALOGE("Could not create handle");
258 nl_socket_free(cmd_sock
);
259 nl_socket_free(event_sock
);
261 return WIFI_ERROR_UNKNOWN
;
264 // ALOGI("cb->refcnt = %d", cb->cb_refcnt);
265 nl_cb_set(cb
, NL_CB_SEQ_CHECK
, NL_CB_CUSTOM
, internal_no_seq_check
, info
);
266 nl_cb_set(cb
, NL_CB_VALID
, NL_CB_CUSTOM
, internal_valid_message_handler
, info
);
269 info
->cmd_sock
= cmd_sock
;
270 info
->event_sock
= event_sock
;
271 info
->clean_up
= false;
272 info
->in_event_loop
= false;
274 info
->event_cb
= (cb_info
*)malloc(sizeof(cb_info
) * DEFAULT_EVENT_CB_SIZE
);
275 info
->alloc_event_cb
= DEFAULT_EVENT_CB_SIZE
;
276 info
->num_event_cb
= 0;
278 info
->cmd
= (cmd_info
*)malloc(sizeof(cmd_info
) * DEFAULT_CMD_SIZE
);
279 info
->alloc_cmd
= DEFAULT_CMD_SIZE
;
282 info
->nl80211_family_id
= genl_ctrl_resolve(cmd_sock
, "nl80211");
283 if (info
->nl80211_family_id
< 0) {
284 ALOGE("Could not resolve nl80211 familty id");
285 nl_socket_free(cmd_sock
);
286 nl_socket_free(event_sock
);
288 return WIFI_ERROR_UNKNOWN
;
291 pthread_mutex_init(&info
->cb_lock
, NULL
);
293 *handle
= (wifi_handle
) info
;
294 wifi_add_membership(*handle
, "scan");
295 wifi_add_membership(*handle
, "mlme");
296 wifi_add_membership(*handle
, "regulatory");
297 wifi_add_membership(*handle
, "vendor");
299 wifi_init_interfaces(*handle
);
300 char intf_name_buff
[10 * 10 + 4]; /* Randomly choosen max interface 10. each interface name max 9 + 1(for space) */
301 char *pos
= intf_name_buff
;
302 for (int i
= 0; i
< (info
->num_interfaces
< 10 ? info
->num_interfaces
: 10); i
++) {
303 strncpy(pos
, info
->interfaces
[i
]->name
, sizeof(intf_name_buff
) - (pos
- intf_name_buff
));
306 if (info
->num_interfaces
> 10) {
307 strncpy(pos
, "...", 3);
310 ALOGD("Found %d interfaces[%s]. Initialized Wifi HAL Successfully", info
->num_interfaces
, intf_name_buff
);
315 static int wifi_add_membership(wifi_handle handle
, const char *group
)
317 hal_info
*info
= getHalInfo(handle
);
319 int id
= wifi_get_multicast_id(handle
, "nl80211", group
);
321 ALOGE("Could not find group %s", group
);
325 int ret
= nl_socket_add_membership(info
->event_sock
, id
);
327 ALOGE("Could not add membership to group %s", group
);
332 static void internal_cleaned_up_handler(wifi_handle handle
)
334 hal_info
*info
= getHalInfo(handle
);
335 wifi_cleaned_up_handler cleaned_up_handler
= info
->cleaned_up_handler
;
337 if (info
->cmd_sock
!= 0) {
338 close(info
->cleanup_socks
[0]);
339 close(info
->cleanup_socks
[1]);
340 nl_socket_free(info
->cmd_sock
);
341 nl_socket_free(info
->event_sock
);
342 info
->cmd_sock
= NULL
;
343 info
->event_sock
= NULL
;
346 (*cleaned_up_handler
)(handle
);
347 pthread_mutex_destroy(&info
->cb_lock
);
351 void wifi_cleanup(wifi_handle handle
, wifi_cleaned_up_handler handler
)
353 hal_info
*info
= getHalInfo(handle
);
356 info
->cleaned_up_handler
= handler
;
357 if (write(info
->cleanup_socks
[0], "Exit", 4) < 1) {
358 ALOGE("could not write to the cleanup socket");
360 // Listen to the response
361 // Hopefully we dont get errors or get hung up
362 // Not much can be done in that case, but assume that
363 // it has rx'ed the Exit message to exit the thread.
364 // As a fallback set the cleanup flag to TRUE
365 memset(buf
, 0, sizeof(buf
));
366 int result
= read(info
->cleanup_socks
[0], buf
, sizeof(buf
));
367 ALOGE("%s: Read after POLL returned %d, error no = %d", __FUNCTION__
, result
, errno
);
368 if (strncmp(buf
, "Done", 4) != 0) {
369 ALOGD("Rx'ed %s", buf
);
372 info
->clean_up
= true;
373 pthread_mutex_lock(&info
->cb_lock
);
375 int bad_commands
= 0;
377 while (info
->num_cmd
> bad_commands
) {
378 int num_cmd
= info
->num_cmd
;
379 cmd_info
*cmdi
= &(info
->cmd
[bad_commands
]);
380 WifiCommand
*cmd
= cmdi
->cmd
;
382 pthread_mutex_unlock(&info
->cb_lock
);
384 pthread_mutex_lock(&info
->cb_lock
);
385 /* release reference added when command is saved */
387 if (num_cmd
== info
->num_cmd
) {
393 for (int i
= 0; i
< info
->num_event_cb
; i
++) {
394 cb_info
*cbi
= &(info
->event_cb
[i
]);
395 WifiCommand
*cmd
= (WifiCommand
*)cbi
->cb_arg
;
396 ALOGE("Leaked command %p", cmd
);
398 pthread_mutex_unlock(&info
->cb_lock
);
399 internal_cleaned_up_handler(handle
);
402 static int internal_pollin_handler(wifi_handle handle
)
404 hal_info
*info
= getHalInfo(handle
);
405 struct nl_cb
*cb
= nl_socket_get_cb(info
->event_sock
);
406 int res
= nl_recvmsgs(info
->event_sock
, cb
);
411 /* Run event handler */
412 void wifi_event_loop(wifi_handle handle
)
414 hal_info
*info
= getHalInfo(handle
);
415 if (info
->in_event_loop
) {
418 info
->in_event_loop
= true;
422 memset(&pfd
[0], 0, sizeof(pollfd
) * 2);
424 pfd
[0].fd
= nl_socket_get_fd(info
->event_sock
);
425 pfd
[0].events
= POLLIN
;
426 pfd
[1].fd
= info
->cleanup_socks
[1];
427 pfd
[1].events
= POLLIN
;
432 int timeout
= -1; /* Infinite timeout */
435 int result
= poll(pfd
, 2, timeout
);
437 } else if (pfd
[0].revents
& POLLERR
) {
438 int prev_err
= (int)errno
;
439 int result2
= read(pfd
[0].fd
, buf
, sizeof(buf
));
440 ALOGE("Poll err:%d | Read after POLL returned %d, error no = %d", prev_err
, result2
, errno
);
441 } else if (pfd
[0].revents
& POLLHUP
) {
442 ALOGE("Remote side hung up");
444 } else if (pfd
[0].revents
& POLLIN
) {
445 internal_pollin_handler(handle
);
446 } else if (pfd
[1].revents
& POLLIN
) {
447 memset(buf
, 0, sizeof(buf
));
448 int result2
= read(pfd
[1].fd
, buf
, sizeof(buf
));
449 ALOGE("%s: Read after POLL returned %d, error no = %d", __FUNCTION__
, result2
, errno
);
450 if (strncmp(buf
, "Exit", 4) == 0) {
451 ALOGD("Got a signal to exit!!!");
452 if (write(pfd
[1].fd
, "Done", 4) < 1) {
453 ALOGE("could not write to the cleanup socket");
457 ALOGD("Rx'ed %s on the cleanup socket\n", buf
);
460 ALOGE("Unknown event - %0x, %0x", pfd
[0].revents
, pfd
[1].revents
);
462 } while (!info
->clean_up
);
465 ///////////////////////////////////////////////////////////////////////////////////////
467 static int internal_no_seq_check(struct nl_msg
*msg
, void *arg
)
472 static int internal_valid_message_handler(nl_msg
*msg
, void *arg
)
474 wifi_handle handle
= (wifi_handle
)arg
;
475 hal_info
*info
= getHalInfo(handle
);
477 WifiEvent
event(msg
);
478 int res
= event
.parse();
480 ALOGE("Failed to parse event: %d", res
);
484 int cmd
= event
.get_cmd();
485 uint32_t vendor_id
= 0;
488 if (cmd
== NL80211_CMD_VENDOR
) {
489 vendor_id
= event
.get_u32(NL80211_ATTR_VENDOR_ID
);
490 subcmd
= event
.get_u32(NL80211_ATTR_VENDOR_SUBCMD
);
492 ALOGI("event received %s, vendor_id = 0x%0x, subcmd = 0x%0x",
493 event.get_cmdString(), vendor_id, subcmd);*/
496 //ALOGI("event received %s, vendor_id = 0x%0x", event.get_cmdString(), vendor_id);
499 pthread_mutex_lock(&info
->cb_lock
);
501 for (int i
= 0; i
< info
->num_event_cb
; i
++) {
502 if (cmd
== info
->event_cb
[i
].nl_cmd
) {
503 if (cmd
== NL80211_CMD_VENDOR
504 && ((vendor_id
!= info
->event_cb
[i
].vendor_id
)
505 || (subcmd
!= info
->event_cb
[i
].vendor_subcmd
)))
507 /* event for a different vendor, ignore it */
511 cb_info
*cbi
= &(info
->event_cb
[i
]);
512 nl_recvmsg_msg_cb_t cb_func
= cbi
->cb_func
;
513 void *cb_arg
= cbi
->cb_arg
;
514 WifiCommand
*cmd
= (WifiCommand
*)cbi
->cb_arg
;
519 pthread_mutex_unlock(&info
->cb_lock
);
521 (*cb_func
)(msg
, cb_arg
);
530 pthread_mutex_unlock(&info
->cb_lock
);
534 ///////////////////////////////////////////////////////////////////////////////////////
536 class GetMulticastIdCommand
: public WifiCommand
543 GetMulticastIdCommand(wifi_handle handle
, const char *name
, const char *group
)
544 : WifiCommand(handle
, 0)
555 virtual int create() {
556 int nlctrlFamily
= genl_ctrl_resolve(mInfo
->cmd_sock
, "nlctrl");
557 int ret
= mMsg
.create(nlctrlFamily
, CTRL_CMD_GETFAMILY
, 0, 0);
561 ret
= mMsg
.put_string(CTRL_ATTR_FAMILY_NAME
, mName
);
565 virtual int handleResponse(WifiEvent
& reply
) {
566 struct nlattr
**tb
= reply
.attributes();
567 struct nlattr
*mcgrp
= NULL
;
570 if (!tb
[CTRL_ATTR_MCAST_GROUPS
]) {
571 ALOGE("No multicast groups found");
575 for_each_attr(mcgrp
, tb
[CTRL_ATTR_MCAST_GROUPS
], i
) {
577 struct nlattr
*tb2
[CTRL_ATTR_MCAST_GRP_MAX
+ 1];
578 nla_parse(tb2
, CTRL_ATTR_MCAST_GRP_MAX
, (nlattr
*)nla_data(mcgrp
),
579 nla_len(mcgrp
), NULL
);
580 if (!tb2
[CTRL_ATTR_MCAST_GRP_NAME
] || !tb2
[CTRL_ATTR_MCAST_GRP_ID
]) {
584 char *grpName
= (char *)nla_data(tb2
[CTRL_ATTR_MCAST_GRP_NAME
]);
585 int grpNameLen
= nla_len(tb2
[CTRL_ATTR_MCAST_GRP_NAME
]);
587 if (strncmp(grpName
, mGroup
, grpNameLen
) != 0)
590 mId
= nla_get_u32(tb2
[CTRL_ATTR_MCAST_GRP_ID
]);
599 class SetPnoMacAddrOuiCommand
: public WifiCommand
{
604 feature_set
*feature_matrix
;
608 SetPnoMacAddrOuiCommand(wifi_interface_handle handle
, oui scan_oui
)
609 : WifiCommand(handle
, 0)
613 feature_matrix
= NULL
;
618 int createRequest(WifiRequest
& request
, int subcmd
, byte
*scan_oui
) {
619 int result
= request
.create(GOOGLE_OUI
, subcmd
);
624 nlattr
*data
= request
.attr_start(NL80211_ATTR_VENDOR_DATA
);
625 result
= request
.put(ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI
, scan_oui
, DOT11_OUI_LEN
);
630 request
.attr_end(data
);
636 WifiRequest
request(familyId(), ifaceId());
637 int result
= createRequest(request
, SLSI_NL80211_VENDOR_SUBCMD_SET_GSCAN_OUI
, mOui
);
638 if (result
!= WIFI_SUCCESS
) {
639 ALOGE("failed to create request; result = %d", result
);
643 result
= requestResponse(request
);
644 if (result
!= WIFI_SUCCESS
) {
645 ALOGE("failed to set scanning mac OUI; result = %d", result
);
651 virtual int handleResponse(WifiEvent
& reply
) {
652 /* Nothing to do on response! */
657 class SetNodfsCommand
: public WifiCommand
{
662 SetNodfsCommand(wifi_interface_handle handle
, u32 nodfs
)
663 : WifiCommand(handle
, 0) {
666 virtual int create() {
669 ret
= mMsg
.create(GOOGLE_OUI
, SLSI_NL80211_VENDOR_SUBCMD_SET_NODFS
);
671 ALOGE("Can't create message to send to driver - %d", ret
);
675 nlattr
*data
= mMsg
.attr_start(NL80211_ATTR_VENDOR_DATA
);
676 ret
= mMsg
.put_u32(ATTR_NODFS_VALUE
, mNoDfs
);
686 class SetRSSIMonitorCommand
: public WifiCommand
{
690 wifi_rssi_event_handler mHandler
;
692 SetRSSIMonitorCommand(wifi_request_id id
, wifi_interface_handle handle
,
693 s8 max_rssi
, s8 min_rssi
, wifi_rssi_event_handler eh
)
694 : WifiCommand(handle
, id
), mMax_rssi(max_rssi
), mMin_rssi
695 (min_rssi
), mHandler(eh
)
698 int createRequest(WifiRequest
& request
, int enable
) {
699 int result
= request
.create(GOOGLE_OUI
, SLSI_NL80211_VENDOR_SUBCMD_SET_RSSI_MONITOR
);
704 nlattr
*data
= request
.attr_start(NL80211_ATTR_VENDOR_DATA
);
705 result
= request
.put_u8(RSSI_MONITOR_ATTRIBUTE_MAX_RSSI
, (enable
? mMax_rssi
: 0));
710 result
= request
.put_u8(RSSI_MONITOR_ATTRIBUTE_MIN_RSSI
, (enable
? mMin_rssi
: 0));
714 result
= request
.put_u8(RSSI_MONITOR_ATTRIBUTE_START
, enable
);
718 request
.attr_end(data
);
723 WifiRequest
request(familyId(), ifaceId());
724 int result
= createRequest(request
, 1);
728 result
= requestResponse(request
);
730 ALOGI("Failed to set RSSI Monitor, result = %d", result
);
733 ALOGI("Successfully set RSSI monitoring");
734 registerVendorHandler(GOOGLE_OUI
, WIFI_RSSI_REPORT_EVENT
);
739 virtual int cancel() {
741 WifiRequest
request(familyId(), ifaceId());
742 int result
= createRequest(request
, 0);
743 if (result
!= WIFI_SUCCESS
) {
744 ALOGE("failed to create request; result = %d", result
);
746 result
= requestResponse(request
);
747 if (result
!= WIFI_SUCCESS
) {
748 ALOGE("failed to stop RSSI monitoring = %d", result
);
751 unregisterVendorHandler(GOOGLE_OUI
, WIFI_RSSI_REPORT_EVENT
);
755 virtual int handleResponse(WifiEvent
& reply
) {
756 /* Nothing to do on response! */
760 virtual int handleEvent(WifiEvent
& event
) {
762 nlattr
*vendor_data
= event
.get_attribute(NL80211_ATTR_VENDOR_DATA
);
763 int len
= event
.get_vendor_data_len();
765 if (vendor_data
== NULL
|| len
== 0) {
766 ALOGI("RSSI monitor: No data");
775 rssi_monitor_evt
*data
= (rssi_monitor_evt
*)event
.get_vendor_data();
777 if (*mHandler
.on_rssi_threshold_breached
) {
778 (*mHandler
.on_rssi_threshold_breached
)(id(), data
->BSSID
, data
->cur_rssi
);
780 ALOGW("No RSSI monitor handler registered");
788 class SetCountryCodeCommand
: public WifiCommand
{
790 const char *mCountryCode
;
792 SetCountryCodeCommand(wifi_interface_handle handle
, const char *country_code
)
793 : WifiCommand(handle
, 0) {
794 mCountryCode
= country_code
;
796 virtual int create() {
799 ret
= mMsg
.create(GOOGLE_OUI
, SLSI_NL80211_VENDOR_SUBCMD_SET_COUNTRY_CODE
);
801 ALOGE("Can't create message to send to driver - %d", ret
);
805 nlattr
*data
= mMsg
.attr_start(NL80211_ATTR_VENDOR_DATA
);
806 ret
= mMsg
.put_string(ATTR_COUNTRY_CODE
, mCountryCode
);
817 class GetFeatureSetCommand
: public WifiCommand
{
824 GetFeatureSetCommand(wifi_interface_handle handle
, feature_set
*set
)
825 : WifiCommand(handle
, 0)
830 virtual int create() {
833 ret
= mMsg
.create(GOOGLE_OUI
, SLSI_NL80211_VENDOR_SUBCMD_GET_FEATURE_SET
);
835 ALOGE("create failed - %d", ret
);
842 virtual int handleResponse(WifiEvent
& reply
) {
844 if (reply
.get_cmd() != NL80211_CMD_VENDOR
) {
845 ALOGD("Ignore reply; cmd = %d", reply
.get_cmd());
849 nlattr
*vendor_data
= reply
.get_attribute(NL80211_ATTR_VENDOR_DATA
);
850 int len
= reply
.get_vendor_data_len();
852 if (vendor_data
== NULL
|| len
== 0) {
853 ALOGE("vendor data in GetFeatureSetCommand missing!!");
857 void *data
= reply
.get_vendor_data();
859 ALOGE("feature_set Pointer not set");
862 memcpy(fset
, data
, min(len
, (int) sizeof(*fset
)));
870 static int wifi_get_multicast_id(wifi_handle handle
, const char *name
, const char *group
)
872 GetMulticastIdCommand
cmd(handle
, name
, group
);
873 int res
= cmd
.requestResponse();
880 /////////////////////////////////////////////////////////////////////////
882 static bool is_wifi_interface(const char *name
)
884 if (strncmp(name
, "wlan", 4) != 0 && strncmp(name
, "p2p", 3) != 0) {
885 /* not a wifi interface; ignore it */
892 static int get_interface(const char *name
, interface_info
*info
)
894 strcpy(info
->name
, name
);
895 info
->id
= if_nametoindex(name
);
899 wifi_error
wifi_init_interfaces(wifi_handle handle
)
901 hal_info
*info
= (hal_info
*)handle
;
904 DIR *d
= opendir("/sys/class/net");
906 return WIFI_ERROR_UNKNOWN
;
909 while ((de
= readdir(d
))) {
910 if (de
->d_name
[0] == '.')
912 if (is_wifi_interface(de
->d_name
) ) {
919 d
= opendir("/sys/class/net");
921 return WIFI_ERROR_UNKNOWN
;
923 info
->interfaces
= (interface_info
**)malloc(sizeof(interface_info
*) * n
);
926 while ((de
= readdir(d
))) {
927 if (de
->d_name
[0] == '.')
929 if (is_wifi_interface(de
->d_name
)) {
930 interface_info
*ifinfo
= (interface_info
*)malloc(sizeof(interface_info
));
931 if (get_interface(de
->d_name
, ifinfo
) != WIFI_SUCCESS
) {
935 ifinfo
->handle
= handle
;
936 info
->interfaces
[i
] = ifinfo
;
943 info
->num_interfaces
= n
;
947 wifi_error
wifi_get_ifaces(wifi_handle handle
, int *num
, wifi_interface_handle
**interfaces
)
949 hal_info
*info
= (hal_info
*)handle
;
951 *interfaces
= (wifi_interface_handle
*)info
->interfaces
;
952 *num
= info
->num_interfaces
;
957 wifi_error
wifi_get_iface_name(wifi_interface_handle handle
, char *name
, size_t size
)
959 interface_info
*info
= (interface_info
*)handle
;
960 strcpy(name
, info
->name
);
964 wifi_error
wifi_get_concurrency_matrix(wifi_interface_handle handle
, int set_size_max
,
965 feature_set set
[], int *set_size
)
967 return WIFI_ERROR_NOT_SUPPORTED
;
970 wifi_error
wifi_set_scanning_mac_oui(wifi_interface_handle handle
, oui scan_oui
)
972 SetPnoMacAddrOuiCommand
command(handle
, scan_oui
);
973 return (wifi_error
)command
.start();
977 wifi_error
wifi_set_nodfs_flag(wifi_interface_handle handle
, u32 nodfs
)
979 SetNodfsCommand
command(handle
, nodfs
);
980 return (wifi_error
) command
.requestResponse();
983 static wifi_error
wifi_start_rssi_monitoring(wifi_request_id id
, wifi_interface_handle
984 iface
, s8 max_rssi
, s8 min_rssi
, wifi_rssi_event_handler eh
)
986 ALOGD("Start RSSI monitor %d", id
);
987 wifi_handle handle
= getWifiHandle(iface
);
988 SetRSSIMonitorCommand
*cmd
= new SetRSSIMonitorCommand(id
, iface
, max_rssi
, min_rssi
, eh
);
989 wifi_register_cmd(handle
, id
, cmd
);
991 wifi_error result
= (wifi_error
)cmd
->start();
992 if (result
!= WIFI_SUCCESS
) {
993 wifi_unregister_cmd(handle
, id
);
999 static wifi_error
wifi_stop_rssi_monitoring(wifi_request_id id
, wifi_interface_handle iface
)
1001 ALOGD("Stopping RSSI monitor");
1004 wifi_rssi_event_handler handler
;
1005 memset(&handler
, 0, sizeof(handler
));
1006 SetRSSIMonitorCommand
*cmd
= new SetRSSIMonitorCommand(id
, iface
,
1010 return WIFI_SUCCESS
;
1012 return wifi_cancel_cmd(id
, iface
);
1015 wifi_error
wifi_get_supported_feature_set(wifi_interface_handle handle
, feature_set
*set
)
1017 GetFeatureSetCommand
command(handle
, set
);
1018 return (wifi_error
) command
.requestResponse();
1021 wifi_error
wifi_set_country_code(wifi_interface_handle handle
, const char *country_code
)
1023 SetCountryCodeCommand
command(handle
, country_code
);
1024 return (wifi_error
) command
.requestResponse();
1028 /////////////////////////////////////////////////////////////////////////////