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;
    89. /* WifiModule初始化 */
    90. static int16_t HdfWifiModuleInit(const struct HdfConfigWifiModuleConfig *config)
    91. {
    92.     if (config == NULL) {
    93.         return HDF_FAILURE;
    94.     }
    95.     /* 创建Module */
    96.     struct WifiModule *module = WifiModuleCreate(config);
    97.     if (module == NULL) {
    98.         return HDF_FAILURE;
    99.     }
    100.     g_hdfWifiProductData.module = module;
    101.     HDF_LOGD("%s:hdf wifi module init succ", __func__);
    103.     return HDF_SUCCESS;
    104. }
    106. /* 通过芯片的名称获取相应的芯片驱动 */
    107. static struct HdfWifiChipData *HdfWifiFindChipDriverByName(const char *chipName)
    108. {
    109.     if (chipName == NULL) {
    110.         return NULL;
    111.     }
    113.     bool found = FALSE;
    114.     struct HdfWifiChipData *chipDriver = NULL;
    115.     int32_t chipNum = sizeof(g_wifiChips) / sizeof(g_wifiChips[0]);
    117.     /* 循环遍历所配置的芯片，返回匹配的芯片驱动 */
    118.     for (int32_t i = 0; i < chipNum; i++) {
    119.         chipDriver = g_wifiChips[i];
    120.         if (chipDriver != NULL && !strcmp(chipDriver->name, chipName)) {
    121.             found = TRUE;
    122.             HDF_LOGI("%s: find chip %s", __func__, chipName);
    123.             break;
    124.         }
    125.     }
    127.     return found ? chipDriver : NULL;
    128. }
    130. /* 芯片初始化 */
    131. static int16_t HdfWifiChipInit(struct WifiModule *module, const struct HdfConfigWifiChip *chipConfig)
    132. {
    133.     int32_t ret;
    135.     if (module == NULL) {
    136.         HDF_LOGE("%s: module is NULL", __func__);
    137.         return HDF_FAILURE;
    138.     }
    140.     /* 通过芯片的名称获取相应的芯片驱动 */
    141.     struct HdfWifiChipData *chipDriver = HdfWifiFindChipDriverByName(chipConfig->chipName);
    142.     if (chipDriver == NULL) {
    143.         HDF_LOGI("%s: chip driver %s not supported", __func__, chipConfig->chipName);
    144.         return HDF_DEV_ERR_OP;
    145.     }
    147.     if (chipDriver->init == NULL) {
    148.         HDF_LOGI("%s: chip driver %s not 'init' api", __func__, chipConfig->chipName);
    149.         return HDF_DEV_ERR_OP;
    150.     }
    152.     /* 初始化芯片 */
    153.     ret = chipDriver->init(chipDriver, chipConfig);
    154.     if (ret != HDF_SUCCESS) {
    155.         HDF_LOGE("%s:init chip %s error ret=%d", __func__, chipConfig->chipName, ret);
    156.         return HDF_DEV_ERR_OP;
    157.     }
    159.     /* 将芯片和feature进行绑定 */
    160.     for (uint32_t i = 0; i < HDF_WIFI_FEATURE_NUM; i++) {
    161.         if ((module->feList->fe[i] != NULL) && (chipConfig->featureMap & (1 << i))) {
    162.             HDF_LOGI("%s:reg chip to feature %d", __func__, i);
    163.             module->feList->fe[i]->chip = chipDriver;
    164.         }
    165.     }
    166.     HDF_LOGI("%s:init chip %s success!", __func__, chipConfig->chipName);
    167.     return HDF_SUCCESS;
    168. }
    170. /* WLAN平台初始化 */
    171. static int16_t HdfWifiPlatformInit(const struct HdfConfigWifiModuleConfig *config)
    172. {
    173.     /* 根据配置进行module初始化 */
    174.     int32_t ret = HdfWifiModuleInit(config);
    176.         return ret;
    177.     }
    179.     return ret;
    180. }
    182. struct HdfWifiProductData *HdfWifiGetProduct(void)
    183. {
    184.     return &g_hdfWifiProductData;
    185. }
    187. static int32_t HdfWifiDriverInit(struct HdfDeviceObject *device)
    188. {
    189.     int32_t ret;
    190.     HDF_LOGD("%s:start..", __func__);
    191.     if (device == NULL) {
    192.         return HDF_FAILURE;
    193.     }
    194.     /* 配置分析（初始化WLAN配置） */
    195.     ret = HdfWifiProductInit(device);
    196.     if (ret != HDF_SUCCESS) {
    197.         HDF_LOGE("%s:init produt cfg error ret=%d", __func__, ret);
    198.         return ret;
    199.     }
    200.     /* 获取全量配置的结构体对象 */
    201.     struct HdfConfigWifiRoot *rootConfig = HdfWifiGetModuleConfigRoot();
    202.     struct HdfWifiProductData *wifiData = HdfWifiGetProduct();
    203.     const struct HdfConfigWifiModuleConfig *moduleConfig = &rootConfig->wifiConfig.moduleConfig;
    204.     /* WIFI平台的初始化（Module初始化） */
    205.     ret = HdfWifiPlatformInit(moduleConfig);
    206.     if (ret) {
    207.         HDF_LOGE("%s:init platform error ret=%d", __func__, ret);
    208.         return ret;
    209.     }
    211.     /* 循环遍历所配置的芯片，并初始化有相应硬件的芯片 */
    212.     for (int16_t i = 0; i < rootConfig->wifiConfig.deviceList.chipSize; i++) {
    213.         const struct HdfConfigWifiChip *chipConfig = &rootConfig->wifiConfig.deviceList.chip[i];
    214.         ret = HdfWifiChipInit(wifiData->module, chipConfig);
    215.         if (ret != HDF_SUCCESS) {
    216.             HDF_LOGE("%s:init chip %d error ret=%d, feature %d is unavailable!", __func__, i, ret,
    217.                 chipConfig->featureMap);
    218.         } else {
    219.             wifiData->device = device;
    220.             HDF_LOGE("%s:init chip %d success!", __func__, i);
    221.             break;
    222.         }
    223.     }
    225.     HDF_LOGD("%s:success..", __func__);
    226.     return ret;
    227. }
    229. int32_t HdfWifiDriverDispatch(struct HdfDeviceIoClient *client, int id, struct HdfSBuf *data, struct HdfSBuf *reply)
    230. {
    231.     if (client == NULL) {
    232.         return HDF_ERR_INVALID_PARAM;
    233.     }
    234.     return WifiCmdProcess(client->device, id, data, reply);
    235. }
    237. static int HdfWifiDriverBind(struct HdfDeviceObject *dev)
    238. {
    239.     if (dev == NULL) {
    240.         return HDF_FAILURE;
    241.     }
    242.     static struct IDeviceIoService wifiService = {
    243.         .object.objectId = 1,
    244.         .Dispatch = HdfWifiDriverDispatch,
    245.     };
    246.     dev->service = &wifiService;
    247.     return HDF_SUCCESS;
    248. }
    250. static void HdfWifiDriverRelease(struct HdfDeviceObject *object)
    251. {
    252.     (void)object;
    253. }
    255. struct HdfDriverEntry g_hdfWifiEntry = {
    256.     .moduleVersion = 1,
    257.     .Bind = HdfWifiDriverBind,
    258.     .Init = HdfWifiDriverInit,
    259.     .Release = HdfWifiDriverRelease,
    260.     .moduleName = "HDF_WIFI"
    261. };