Android系统硬件抽象层原理与实现之WIFI

作者：朱克锋

转载请注明出处：http://blog.youkuaiyun.com/linux_zkf/article/details/7492391

 

Android系统硬件抽象层原理与实现之WIFI

本文我将主要分析wifi的硬件抽象层的实现和WPA相关的东西，wifi是一种无线网路通信技术，相关的介绍网络上有很多，介绍的也很全面，这里我就不在过多的介绍了，作为一种无线网络产品，其在android系统中也有其功能体现。

在android系统中wifi系统包括：linux kernel 中的驱动，协议，本地部分，java框架。本文主要介绍的是本地部分也就是HAL层的实现

首先看看wifi在android系统中的结构：

 

WIFI APP

 

FRAMEWORK

 

JNI

 

WIFI HAL

 

WPA

 

DRIVER + PROTOCOL

 

由上图可以看出wifi本地部分主要是HAL+WPA两部分，其中HAL部分对上层提供接口，并且与WPA交互，最终具体的实现是有WPA层实现的，可以说WIFI HAL是一个适配层更加合适。

 Wifi硬件抽象层代码在源码种的位置：

hardware/libhardware_legacy/wifi/wifi.c

hardware/libhardware_legacy/include/libhardware_legacy/wifi.h

wpa在external/wpa_supplicant/

 

整个WIFIHAL实现都很简单，都是对wpa_supplicant的操作和使用，如果需要自己实现WIFIHAL可以参考wifi.c来实现wifi.h中所定义的接口，并且设置驱动的路径、名称、模块的名称等参数，具体操作都将由wpa_supplicant来完成。

其中wifi.h定义了Android系统中WIFI硬件抽象层接口，wifi.h定义

//装载wifi驱动

int wifi_load_driver();

//缷载wifi驱动

int wifi_unload_driver();

//开始、停止supplicant

int wifi_start_supplicant();

int wifi_stop_supplicant();

//连接supplicant

int wifi_connect_to_supplicant();

//关闭supplicant连接

voidwifi_close_supplicant_connection();

int wifi_wait_for_event(char *buf,size_t len);

int wifi_command(const char *command,char *reply, size_t *reply_len);

// DHCP请求

int do_dhcp_request(int *ipaddr, int*gateway, int *mask, int *dns1, int *dns2, int *server, int *lease);

const char *get_dhcp_error_string();

操作接口都很简单，其中比较重要的是wifi_wait_for_event和wifi_command函数，前者用于接收wpa_supplicant上报的事件，而后者用于向wpa_supplicant进程发送命令.

下面来看看wifi_wait_for_event的实现

int wifi_wait_for_event(char *buf, size_t buflen)

{

   size_t nread = buflen - 1;

   int fd;

   fd_set rfds;

   int result;

   struct timeval tval;

   struct timeval *tptr;

 

   if (monitor_conn == NULL) {

       LOGD("Connection closed\n");

       strncpy(buf, WPA_EVENT_TERMINATING " - connection closed", buflen-1);

       buf[buflen-1] = '\0';

       return strlen(buf);

   }

 

   result = wifi_ctrl_recv(monitor_conn, buf, &nread);

   if (result < 0) {

       LOGD("wifi_ctrl_recv failed: %s\n", strerror(errno));

       strncpy(buf, WPA_EVENT_TERMINATING " - recv error", buflen-1);

       buf[buflen-1] = '\0';

       return strlen(buf);

   }

   buf[nread] = '\0';

   /* LOGD("wait_for_event: result=%d nread=%d string=\"%s\"\n", result, nread, buf); */

   /* Check for EOF on the socket */

   if (result == 0 && nread == 0) {

       /* Fabricate an event to pass up */

       LOGD("Received EOF on supplicant socket\n");

       strncpy(buf, WPA_EVENT_TERMINATING " - signal 0 received", buflen-1);

       buf[buflen-1] = '\0';

       return strlen(buf);

   }

   /*

    * Events strings are in the format

    *

    *     <N>CTRL-EVENT-XXX

    *

    * where N is the message level in numerical form (0=VERBOSE, 1=DEBUG,

    * etc.) and XXX is the event name. The level information is not useful

    * to us, so strip it off.

    */

   if (buf[0] == '<') {

       char *match = strchr(buf, '>');

       if (match != NULL) {

           nread -= (match+1-buf);

           memmove(buf, match+1, nread+1);

       }

   }

   return nread;

}

int wifi_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len)

{

   int res;

   int ctrlfd = wpa_ctrl_get_fd(ctrl);

   struct pollfd rfds[2];

 

   memset(rfds, 0, 2 * sizeof(struct pollfd));

   rfds[0].fd = ctrlfd;

   rfds[0].events |= POLLIN;

   rfds[1].fd = exit_sockets[1];

   rfds[1].events |= POLLIN;

   res = poll(rfds, 2, -1);

   if (res < 0) {

       LOGE("Error poll = %d", res);

       return res;

   }

   if (rfds[0].revents & POLLIN) {

       return wpa_ctrl_recv(ctrl, reply, reply_len);

   } else {

       LOGD("Received on exit socket, terminate");

       return -1;

   }

   return 0;

}

 

其中wifi_ctrl_recv中的wpa_ctrl_recv(ctrl, reply, reply_len)是wpa_ctrl提供的wpa_ctrl_recv接口，来接收事件。

wifi_command函数，用于向wpa_supplicant进程发送命令

int wifi_command(const char *command, char *reply, size_t *reply_len)

{

   return wifi_send_command(ctrl_conn, command, reply, reply_len);

}

wifi_command函数会调用wifi_send_command来实现命令的发送，发送过程同样使用wpa_ctrl提供的wpa_ctrl_request接口来完成

 

int wifi_send_command(struct wpa_ctrl *ctrl, const char *cmd, char *reply, size_t *reply_len)

{

   int ret;

 

   if (ctrl_conn == NULL) {

       LOGV("Not connected to wpa_supplicant - \"%s\" command dropped.\n", cmd);

       return -1;

   }

   ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), reply, reply_len, NULL);

   if (ret == -2) {

       LOGD("'%s' command timed out.\n", cmd);

       /* unblocks the monitor receive socket for termination */

       write(exit_sockets[0], "T", 1);

       return -2;

   } else if (ret < 0 || strncmp(reply, "FAIL", 4) == 0) {

       return -1;

   }

   if (strncmp(cmd, "PING", 4) == 0) {

       reply[*reply_len] = '\0';

   }

   return 0;

}

 

在wifi.c中还有一点很重要，就是在wifi_connect_to_supplicant函数中调用wpa_ctrl_open函数创建两个socket，一个是ctrlinterface,另一个是 monitorinterface。Monitorinterface用于监测从wpa_supplicant发出的event事件，当两个socket创建成功后，monitorinterface会调用wpa_ctrl_attach函数发送ATTACH到wpa_supplicant模块，wpa_supplicant模块收到后，会将该客户端的socket信息记录下来，用于以后发送事件时用。

 

#define SUPPLICANT_TIMEOUT     3000000  // microseconds

#define SUPPLICANT_TIMEOUT_STEP 100000  // microseconds

int wifi_connect_to_supplicant()

{

   char ifname[256];

   char supp_status[PROPERTY_VALUE_MAX] = {'\0'};

   int  supplicant_timeout = SUPPLICANT_TIMEOUT;

 

   /* Make sure supplicant is running */

   if (!property_get(SUPP_PROP_NAME, supp_status, NULL)

           || strcmp(supp_status, "running") != 0) {

       LOGE("Supplicant not running, cannot connect");

       return -1;

   }

 

   if (access(IFACE_DIR, F_OK) == 0) {

       snprintf(ifname, sizeof(ifname), "%s/%s", IFACE_DIR, iface);

   } else {

       strlcpy(ifname, iface, sizeof(ifname));

   }

 

   ctrl_conn = wpa_ctrl_open(ifname);

   while (ctrl_conn == NULL && supplicant_timeout > 0) {

       usleep(SUPPLICANT_TIMEOUT_STEP);

       supplicant_timeout -= SUPPLICANT_TIMEOUT_STEP;

       ctrl_conn = wpa_ctrl_open(ifname);

   }

   if (ctrl_conn == NULL) {

       LOGE("1.Unable to open connection to supplicant on \"%s\": %s",

            ifname, strerror(errno));

       return -1;

   }

   monitor_conn = wpa_ctrl_open(ifname);

   if (monitor_conn == NULL) {

       wpa_ctrl_close(ctrl_conn);

       ctrl_conn = NULL;

       LOGE("2. Unable to open connection to supplicant on \"%s\": %s",

            ifname, strerror(errno));       

       return -1;

   }

   if (wpa_ctrl_attach(monitor_conn) != 0) {

       wpa_ctrl_close(monitor_conn);

       wpa_ctrl_close(ctrl_conn);

       ctrl_conn = monitor_conn = NULL;

       return -1;

   }

 

   if (socketpair(AF_UNIX, SOCK_STREAM, 0, exit_sockets) == -1) {

       wpa_ctrl_close(monitor_conn);

       wpa_ctrl_close(ctrl_conn);

       ctrl_conn = monitor_conn = NULL;

       return -1;

   }

 

   return 0;

}

 

在android系统中对wifi驱动的加载与卸载有些特殊注意下面两个方法

 

static int insmod(const char *filename, const char *args)

{

   void *module;

   unsigned int size;

   int ret;

 

   module = load_file(filename, &size);

   if (!module)

       return -1;

 

   ret = init_module(module, size, args);

 

   free(module);

 

   return ret;

}

 

static int rmmod(const char *modname)

{

   int ret = -1;

   int maxtry = 10;

 

   while (maxtry-- > 0) {

       ret = delete_module(modname, O_NONBLOCK | O_EXCL);

       if (ret < 0 && errno == EAGAIN)

           usleep(500000);

       else

           break;

   }

 

   if (ret != 0)

       LOGD("Unable to unload driver module \"%s\": %s\n",

            modname, strerror(errno));

   return ret;

}

一般的驱动都是在系统启动是加在好的而wifi驱动实在使用时加载，不使用时卸载