WLAN开发实例

本例程提供WLAN模块初始化过程的完整使用流程。示例如下：

1、根据硬件，修改配置参数

  1. /* 根据硬件参数，通过wifi_config.hcs配置相关参数，以下是配置chip的示例 */
  2. hisi :& deviceList {
  3.     C1 :: Chip {
  4.         chipName = "hisi";   /* WLAN芯片的名称 */
  5.         chipId = 0;          /* WLAN芯片的id */
  6.         featureMap = 0xFFFF; /* WLAN模块特性map */
  7.         powerType = 0;       /* 电源类型 */
  8.         irqNo = 0;           /* 中断号 */
  9.         bus {
  10.             busType = 0;       /* 总线类型：0-sdio 1-usb 2-spi etc. */
  11.             funcNum = [1];     /* 功能号 */
  12.             vendorId = 0x0296; /* 厂商id */
  13.             deviceId = 0x5347; /* 设备id */
  14.             timeout = 1000;    /* 读/写数据的超时时间 */
  15.             blockSize = 512;   /* 读/写数据的块大小 */
  16.         }
  17.     }
  18. }
  19. board {
  20.     boardName = "3518EV300";  /* 单板名称 */
  21.     busType = 0;              /* 总线类型 */
  22.     busIdx = 1;               /* 总线索引 */
  23.     reset   = [5,0];          /* GPIO组号和偏移 */
  24.     gpioArgs = [10,10,10];    /* GPIO组数, GPIO每组个数, GPIO中断数 */
  25.     busRegs {
  26.         cclk_out = [0x112C0048, 0x1A04];  /* 时钟线寄存器配置 */
  27.         ccmd     = [0x112C004C, 0x1004];  /* 命令传输线寄存器配 */
  28.         cdata0    = [0x112C0064, 0x1004]; /* 数据0线线寄存器配 */
  29.         cdata1    = [0x112C0058, 0x1004]; /* 数据1线寄存器配 */
  30.         cdata2    = [0x112C005C, 0x1004]; /* 数据2线寄存器配 */
  31.         cdata3    = [0x112C0060, 0x1004]; /* 数据3线寄存器配 */
  32.     }
  33. }

2、适配挂接

  1. /* WLAN初始化流程 */
  2. #include "gpio_if.h"
  3. #include "hdf_wifi_core.h"
  4. #include "hdf_device_desc.h"
  5. #include "hdf_wifi_product.h"
  6. #include "hdf_log.h"
  7. #include "hdf_wifi_cmd.h"
  8. #include "osal_mem.h"
  9. #include "osal_time.h"
  10. #include "hdf_wifi_config.h"
  12. struct HdfWifiProductData g_hdfWifiProductData;
  14. /* 声明芯片驱动 */
  15. HDF_WIFI_CHIP_DECLARE(hisi);
  17. int32_t Hi3881Deinit(struct HdfWifiChipData *chipData);
  18. int32_t Hi3881Init(struct HdfWifiChipData *chipData, const struct HdfConfigWifiChip *chipConfig);
  19. HDF_WIFI_CHIP_DRIVER(hisi, Hi3881Init, Hi3881Deinit);
  21. struct HdfWifiChipData *g_wifiChips[] = {
  22.     HDF_WIFI_CHIP(hisi),
  23. };
  25. /* 声明芯片驱动 */
  26. static const struct HdfConfigWifiBoard *HdfWifiGetBoardConfig(void)
  27. {
  28.     struct HdfConfigWifiRoot *rootConfig = HdfWifiGetModuleConfigRoot();
  30.     return &rootConfig->wifiConfig.board;
  31. }
  33. int32_t HdfWifiGetBusIdx(void)
  34. {
  35.     const struct HdfConfigWifiBoard *board = HdfWifiGetBoardConfig();
  36.     if (board != NULL) {
  37.         return board->busIdx;
  38.     }
  40.     return -1;
  41. }
  43. static void HdfWifiChipReset(void)
  44. {
  45.     const struct HdfConfigWifiBoard *board = HdfWifiGetBoardConfig();
  46.     uint16_t gpio;
  47.     int32_t ret;
  49.     if (board != NULL && board->busType == BUS_SDIO) {
  50.         /* set dir input */
  51.         gpio = board->reset[0] *  board->gpioArgs[1] + board->reset[1];
  52.         ret = GpioSetDir(gpio, 1);
  53.         if (ret != HDF_SUCCESS) {
  54.             HDF_LOGE("%s: set dir fail! ret:%d\n", __func__, ret);
  55.             return;
  56.         }
  57.         /* power off */
  58.         ret = GpioWrite(gpio, 0);
  59.         if (ret != HDF_SUCCESS) {
  60.             HDF_LOGE("%s: val:0 write fail! ret:%d\n", __func__, ret);
  61.             return;
  62.         }
  63.         OsalMSleep(0x10);
  64.         /* power on */
  65.         ret = GpioWrite(gpio, 1);
  66.         if (ret != HDF_SUCCESS) {
  67.             HDF_LOGE("%s: val:1 write fail! ret:%d\n", __func__, ret);
  68.             return;
  69.         }
  70.         OsalMSleep(0x20);
  71.     }
  73.     return;
  74. }
  76. static int32_t HdfWifiProductInit(struct HdfDeviceObject *device)
  77. {
  78.     int32_t ret;
  80.     ret = HdfParseWifiConfig(device->property);
  81.     if (ret != HDF_SUCCESS) {
  82.         HDF_LOGE("%s:ParseWifiConfig error ret=%d", __func__, ret);
  83.         return ret;
  84.     }
  85.     /* reset chip firstly */
  86.     HdfWifiChipReset();
  87.     return HDF_SUCCESS;
  88. }
  90. /* WifiModule初始化 */
  91. static int16_t HdfWifiModuleInit(const struct HdfConfigWifiModuleConfig *config)
  92. {
  93.     if (config == NULL) {
  94.         return HDF_FAILURE;
  95.     }
  96.     /* 创建Module */
  97.     struct WifiModule *module = WifiModuleCreate(config);
  98.     if (module == NULL) {
  99.         return HDF_FAILURE;
  100.     }
  101.     g_hdfWifiProductData.module = module;
  102.     HDF_LOGD("%s:hdf wifi module init succ", __func__);
  104.     return HDF_SUCCESS;
  105. }
  107. /* 通过芯片的名称获取相应的芯片驱动 */
  108. static struct HdfWifiChipData *HdfWifiFindChipDriverByName(const char *chipName)
  109. {
  110.     if (chipName == NULL) {
  111.         return NULL;
  112.     }
  114.     bool found = FALSE;
  115.     struct HdfWifiChipData *chipDriver = NULL;
  116.     int32_t chipNum = sizeof(g_wifiChips) / sizeof(g_wifiChips[0]);
  118.     /* 循环遍历所配置的芯片，返回匹配的芯片驱动 */
  119.     for (int32_t i = 0; i < chipNum; i++) {
  120.         chipDriver = g_wifiChips[i];
  121.         if (chipDriver != NULL && !strcmp(chipDriver->name, chipName)) {
  122.             found = TRUE;
  123.             HDF_LOGI("%s: find chip %s", __func__, chipName);
  124.             break;
  125.         }
  126.     }
  128.     return found ? chipDriver : NULL;
  129. }
  131. /* 芯片初始化 */
  132. static int16_t HdfWifiChipInit(struct WifiModule *module, const struct HdfConfigWifiChip *chipConfig)
  133. {
  134.     int32_t ret;
  136.     if (module == NULL) {
  137.         HDF_LOGE("%s: module is NULL", __func__);
  138.         return HDF_FAILURE;
  139.     }
  141.     /* 通过芯片的名称获取相应的芯片驱动 */
  142.     struct HdfWifiChipData *chipDriver = HdfWifiFindChipDriverByName(chipConfig->chipName);
  143.     if (chipDriver == NULL) {
  144.         HDF_LOGI("%s: chip driver %s not supported", __func__, chipConfig->chipName);
  145.         return HDF_DEV_ERR_OP;
  146.     }
  148.     if (chipDriver->init == NULL) {
  149.         HDF_LOGI("%s: chip driver %s not 'init' api", __func__, chipConfig->chipName);
  150.         return HDF_DEV_ERR_OP;
  151.     }
  153.     /* 初始化芯片 */
  154.     ret = chipDriver->init(chipDriver, chipConfig);
  155.     if (ret != HDF_SUCCESS) {
  156.         HDF_LOGE("%s:init chip %s error ret=%d", __func__, chipConfig->chipName, ret);
  157.         return HDF_DEV_ERR_OP;
  158.     }
  160.     /* 将芯片和feature进行绑定 */
  161.     for (uint32_t i = 0; i < HDF_WIFI_FEATURE_NUM; i++) {
  162.         if ((module->feList->fe[i] != NULL) && (chipConfig->featureMap & (1 << i))) {
  163.             HDF_LOGI("%s:reg chip to feature %d", __func__, i);
  164.             module->feList->fe[i]->chip = chipDriver;
  165.         }
  166.     }
  167.     HDF_LOGI("%s:init chip %s success!", __func__, chipConfig->chipName);
  168.     return HDF_SUCCESS;
  169. }
  171. /* WLAN平台初始化 */
  172. static int16_t HdfWifiPlatformInit(const struct HdfConfigWifiModuleConfig *config)
  173. {
  174.     /* 根据配置进行module初始化 */
  175.     int32_t ret = HdfWifiModuleInit(config);
  176.     if (ret != HDF_SUCCESS) {
  177.         HDF_LOGE("%s:HdfWifiModuleInit error ret=%d", __func__, ret);
  178.         return ret;
  179.     }
  181.     return ret;
  182. }
  184. struct HdfWifiProductData *HdfWifiGetProduct(void)
  185. {
  186.     return &g_hdfWifiProductData;
  187. }
  189. static int32_t HdfWifiDriverInit(struct HdfDeviceObject *device)
  190. {
  191.     int32_t ret;
  192.     HDF_LOGD("%s:start..", __func__);
  193.     if (device == NULL) {
  194.         return HDF_FAILURE;
  195.     }
  196.     /* 配置分析（初始化WLAN配置） */
  197.     ret = HdfWifiProductInit(device);
  198.     if (ret != HDF_SUCCESS) {
  199.         HDF_LOGE("%s:init produt cfg error ret=%d", __func__, ret);
  200.         return ret;
  201.     }
  202.     /* 获取全量配置的结构体对象 */
  203.     struct HdfConfigWifiRoot *rootConfig = HdfWifiGetModuleConfigRoot();
  204.     struct HdfWifiProductData *wifiData = HdfWifiGetProduct();
  205.     const struct HdfConfigWifiModuleConfig *moduleConfig = &rootConfig->wifiConfig.moduleConfig;
  206.     /* WIFI平台的初始化（Module初始化） */
  207.     ret = HdfWifiPlatformInit(moduleConfig);
  208.     if (ret) {
  209.         HDF_LOGE("%s:init platform error ret=%d", __func__, ret);
  210.         return ret;
  211.     }
  213.     /* 循环遍历所配置的芯片，并初始化有相应硬件的芯片 */
  214.     for (int16_t i = 0; i < rootConfig->wifiConfig.deviceList.chipSize; i++) {
  215.         const struct HdfConfigWifiChip *chipConfig = &rootConfig->wifiConfig.deviceList.chip[i];
  216.         ret = HdfWifiChipInit(wifiData->module, chipConfig);
  217.         if (ret != HDF_SUCCESS) {
  218.             HDF_LOGE("%s:init chip %d error ret=%d, feature %d is unavailable!", __func__, i, ret,
  219.                 chipConfig->featureMap);
  220.         } else {
  221.             wifiData->device = device;
  222.             HDF_LOGE("%s:init chip %d success!", __func__, i);
  223.             break;
  224.         }
  225.     }
  227.     HDF_LOGD("%s:success..", __func__);
  228.     return ret;
  229. }
  231. int32_t HdfWifiDriverDispatch(struct HdfDeviceIoClient *client, int id, struct HdfSBuf *data, struct HdfSBuf *reply)
  232. {
  233.     if (client == NULL) {
  234.         return HDF_ERR_INVALID_PARAM;
  235.     }
  236.     return WifiCmdProcess(client->device, id, data, reply);
  237. }
  239. static int HdfWifiDriverBind(struct HdfDeviceObject *dev)
  240. {
  241.     if (dev == NULL) {
  242.         return HDF_FAILURE;
  243.     }
  244.     static struct IDeviceIoService wifiService = {
  245.         .object.objectId = 1,
  246.         .Dispatch = HdfWifiDriverDispatch,
  247.     };
  248.     dev->service = &wifiService;
  249.     return HDF_SUCCESS;
  250. }
  252. static void HdfWifiDriverRelease(struct HdfDeviceObject *object)
  253. {
  254.     (void)object;
  255. }
  257. struct HdfDriverEntry g_hdfWifiEntry = {
  258.     .moduleVersion = 1,
  259.     .Bind = HdfWifiDriverBind,
  260.     .Init = HdfWifiDriverInit,
  261.     .Release = HdfWifiDriverRelease,
  262.     .moduleName = "HDF_WIFI"
  263. };
  265. HDF_INIT(g_hdfWifiEntry);