1 /* 2 * Copyright (c) 2006-2018, RT-Thread Development Team 3 * 4 * SPDX-License-Identifier: Apache-2.0 5 * 6 * Change Logs: 7 * Date Author Notes 8 * 2018-08-03 tyx the first version 9 */ 10 11 #include <rthw.h> 12 #include <rtthread.h> 13 #include <wlan_dev.h> 14 #include <wlan_prot.h> 15 16 #define DBG_ENABLE 17 #ifdef RT_WLAN_DEV_DEBUG 18 #define DBG_LEVEL DBG_LOG 19 #else 20 #define DBG_LEVEL DBG_INFO 21 #endif 22 #define DBG_SECTION_NAME "WLAN.dev" 23 #define DBG_COLOR 24 #include <rtdbg.h> 25 26 #ifndef RT_DEVICE 27 #define RT_DEVICE(__device) ((rt_device_t)__device) 28 #endif 29 30 #define WLAN_DEV_LOCK(_wlan) (rt_mutex_take(&(_wlan)->lock, RT_WAITING_FOREVER)) 31 #define WLAN_DEV_UNLOCK(_wlan) (rt_mutex_release(&(_wlan)->lock)) 32 33 #if RT_WLAN_SSID_MAX_LENGTH < 1 34 #error "SSID length is too short" 35 #endif 36 37 #if RT_WLAN_BSSID_MAX_LENGTH < 1 38 #error "BSSID length is too short" 39 #endif 40 41 #if RT_WLAN_PASSWORD_MAX_LENGTH < 1 42 #error "password length is too short" 43 #endif 44 45 #if RT_WLAN_DEV_EVENT_NUM < 2 46 #error "dev num Too little" 47 #endif 48 49 rt_err_t rt_wlan_dev_init(struct rt_wlan_device *device, rt_wlan_mode_t mode) 50 { 51 rt_err_t result = RT_EOK; 52 53 /* init wlan device */ 54 LOG_D("F:%s L:%d is run device:0x%08x mode:%d", __FUNCTION__, __LINE__, device, mode); 55 if ((device == RT_NULL) || (mode >= RT_WLAN_MODE_MAX)) 56 { 57 LOG_E("F:%s L:%d Parameter Wrongful device:0x%08x mode:%d", __FUNCTION__, __LINE__, device, mode); 58 return -RT_ERROR; 59 } 60 61 result = rt_device_init(RT_DEVICE(device)); 62 if (result != RT_EOK) 63 { 64 LOG_E("L:%d wlan init failed", __LINE__); 65 return -RT_ERROR; 66 } 67 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_MODE, (void *)&mode); 68 if (result != RT_EOK) 69 { 70 LOG_E("L:%d wlan config mode failed", __LINE__); 71 return -RT_ERROR; 72 } 73 device->mode = mode; 74 return result; 75 } 76 77 rt_err_t rt_wlan_dev_connect(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len) 78 { 79 rt_err_t result = RT_EOK; 80 struct rt_sta_info sta_info; 81 82 if (device == RT_NULL) 83 { 84 return -RT_EIO; 85 } 86 if (info == RT_NULL) 87 { 88 return -RT_ERROR; 89 } 90 91 if ((password_len > RT_WLAN_PASSWORD_MAX_LENGTH) || 92 (info->ssid.len > RT_WLAN_SSID_MAX_LENGTH)) 93 { 94 LOG_E("L:%d password or ssid is to long", __LINE__); 95 return -RT_ERROR; 96 } 97 rt_memset(&sta_info, 0, sizeof(struct rt_sta_info)); 98 rt_memcpy(&sta_info.ssid, &info->ssid, sizeof(rt_wlan_ssid_t)); 99 rt_memcpy(sta_info.bssid, info->bssid, RT_WLAN_BSSID_MAX_LENGTH); 100 if (password != RT_NULL) 101 { 102 rt_memcpy(sta_info.key.val, password, password_len); 103 sta_info.key.len = password_len; 104 } 105 sta_info.channel = info->channel; 106 sta_info.security = info->security; 107 108 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_JOIN, &sta_info); 109 return result; 110 } 111 112 rt_err_t rt_wlan_dev_disconnect(struct rt_wlan_device *device) 113 { 114 rt_err_t result = RT_EOK; 115 116 if (device == RT_NULL) 117 { 118 return -RT_EIO; 119 } 120 121 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_DISCONNECT, RT_NULL); 122 return result; 123 } 124 125 rt_err_t rt_wlan_dev_ap_start(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len) 126 { 127 rt_err_t result = RT_EOK; 128 struct rt_ap_info ap_info; 129 130 if (device == RT_NULL) 131 { 132 return -RT_EIO; 133 } 134 if (info == RT_NULL) 135 { 136 return -RT_ERROR; 137 } 138 139 if ((password_len >= RT_WLAN_PASSWORD_MAX_LENGTH) || 140 (info->ssid.len >= RT_WLAN_SSID_MAX_LENGTH)) 141 { 142 LOG_E("L:%d password or ssid is to long", __LINE__); 143 return -RT_ERROR; 144 } 145 146 rt_memset(&ap_info, 0, sizeof(struct rt_ap_info)); 147 rt_memcpy(&ap_info.ssid, &info->ssid, sizeof(rt_wlan_ssid_t)); 148 if (password != RT_NULL) 149 { 150 rt_memcpy(ap_info.key.val, password, password_len); 151 } 152 ap_info.key.len = password_len; 153 ap_info.hidden = info->hidden; 154 ap_info.channel = info->channel; 155 ap_info.security = info->security; 156 157 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SOFTAP, &ap_info); 158 return result; 159 } 160 161 rt_err_t rt_wlan_dev_ap_stop(struct rt_wlan_device *device) 162 { 163 rt_err_t result = RT_EOK; 164 165 if (device == RT_NULL) 166 { 167 return -RT_EIO; 168 } 169 170 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_AP_STOP, RT_NULL); 171 return result; 172 } 173 174 rt_err_t rt_wlan_dev_ap_deauth(struct rt_wlan_device *device, rt_uint8_t mac[6]) 175 { 176 rt_err_t result = RT_EOK; 177 178 if (device == RT_NULL) 179 { 180 return -RT_EIO; 181 } 182 183 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_AP_DEAUTH, mac); 184 return result; 185 } 186 187 int rt_wlan_dev_get_rssi(struct rt_wlan_device *device) 188 { 189 int rssi = 0; 190 rt_err_t result = RT_EOK; 191 192 if (device == RT_NULL) 193 { 194 rt_set_errno(-RT_EIO); 195 return 0; 196 } 197 198 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_RSSI, &rssi); 199 if (result != RT_EOK) 200 { 201 rt_set_errno(result); 202 return 0; 203 } 204 205 return rssi; 206 } 207 208 rt_err_t rt_wlan_dev_get_mac(struct rt_wlan_device *device, rt_uint8_t mac[6]) 209 { 210 rt_err_t result = RT_EOK; 211 212 if (device == RT_NULL) 213 { 214 return -RT_EIO; 215 } 216 217 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_MAC, &mac[0]); 218 return result; 219 } 220 221 rt_err_t rt_wlan_dev_set_mac(struct rt_wlan_device *device, rt_uint8_t mac[6]) 222 { 223 rt_err_t result = RT_EOK; 224 225 if (device == RT_NULL) 226 { 227 return -RT_EIO; 228 } 229 230 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_MAC, &mac[0]); 231 return result; 232 } 233 234 rt_err_t rt_wlan_dev_set_powersave(struct rt_wlan_device *device, int level) 235 { 236 rt_err_t result = RT_EOK; 237 238 if (device == RT_NULL) 239 { 240 return -RT_EIO; 241 } 242 243 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_POWERSAVE, &level); 244 return result; 245 } 246 247 int rt_wlan_dev_get_powersave(struct rt_wlan_device *device) 248 { 249 int level = -1; 250 rt_err_t result = RT_EOK; 251 252 if (device == RT_NULL) 253 { 254 rt_set_errno(-RT_EIO); 255 return -1; 256 } 257 258 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_POWERSAVE, &level); 259 if (result != RT_EOK) 260 { 261 rt_set_errno(result); 262 } 263 264 return level; 265 } 266 267 rt_err_t rt_wlan_dev_register_event_handler(struct rt_wlan_device *device, rt_wlan_dev_event_t event, rt_wlan_dev_event_handler handler, void *parameter) 268 { 269 int i = 0; 270 rt_base_t level; 271 272 if (device == RT_NULL) 273 { 274 return -RT_EIO; 275 } 276 if (event >= RT_WLAN_DEV_EVT_MAX) 277 { 278 return -RT_EINVAL; 279 } 280 281 level = rt_hw_interrupt_disable(); 282 for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++) 283 { 284 if (device->handler_table[event][i].handler == RT_NULL) 285 { 286 device->handler_table[event][i].handler = handler; 287 device->handler_table[event][i].parameter = parameter; 288 rt_hw_interrupt_enable(level); 289 return RT_EOK; 290 } 291 } 292 rt_hw_interrupt_enable(level); 293 294 /* No space found */ 295 return -RT_ERROR; 296 } 297 298 rt_err_t rt_wlan_dev_unregister_event_handler(struct rt_wlan_device *device, rt_wlan_dev_event_t event, rt_wlan_dev_event_handler handler) 299 { 300 int i = 0; 301 rt_base_t level; 302 303 if (device == RT_NULL) 304 { 305 return -RT_EIO; 306 } 307 if (event >= RT_WLAN_DEV_EVT_MAX) 308 { 309 return -RT_EINVAL; 310 } 311 312 level = rt_hw_interrupt_disable(); 313 for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++) 314 { 315 if (device->handler_table[event][i].handler == handler) 316 { 317 rt_memset(&device->handler_table[event][i], 0, sizeof(struct rt_wlan_dev_event_desc)); 318 rt_hw_interrupt_enable(level); 319 return RT_EOK; 320 } 321 } 322 rt_hw_interrupt_enable(level); 323 /* not find iteam */ 324 return -RT_ERROR; 325 } 326 327 void rt_wlan_dev_indicate_event_handle(struct rt_wlan_device *device, rt_wlan_dev_event_t event, struct rt_wlan_buff *buff) 328 { 329 void *parameter[RT_WLAN_DEV_EVENT_NUM]; 330 rt_wlan_dev_event_handler handler[RT_WLAN_DEV_EVENT_NUM]; 331 int i; 332 rt_base_t level; 333 334 if (device == RT_NULL) 335 { 336 return; 337 } 338 if (event >= RT_WLAN_DEV_EVT_MAX) 339 { 340 return; 341 } 342 343 /* get callback handle */ 344 level = rt_hw_interrupt_disable(); 345 for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++) 346 { 347 handler[i] = device->handler_table[event][i].handler; 348 parameter[i] = device->handler_table[event][i].parameter; 349 } 350 rt_hw_interrupt_enable(level); 351 352 /* run callback */ 353 for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++) 354 { 355 if (handler[i] != RT_NULL) 356 { 357 handler[i](device, event, buff, parameter[i]); 358 } 359 } 360 } 361 362 rt_err_t rt_wlan_dev_enter_promisc(struct rt_wlan_device *device) 363 { 364 rt_err_t result = RT_EOK; 365 int enable = 1; 366 367 if (device == RT_NULL) 368 { 369 return -RT_EIO; 370 } 371 372 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_PROMISC, &enable); 373 return result; 374 } 375 376 rt_err_t rt_wlan_dev_exit_promisc(struct rt_wlan_device *device) 377 { 378 rt_err_t result = RT_EOK; 379 int enable = 0; 380 381 if (device == RT_NULL) 382 { 383 return -RT_EIO; 384 } 385 386 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_PROMISC, &enable); 387 return result; 388 } 389 390 rt_err_t rt_wlan_dev_set_promisc_callback(struct rt_wlan_device *device, rt_wlan_pormisc_callback_t callback) 391 { 392 if (device == RT_NULL) 393 { 394 return -RT_EIO; 395 } 396 device->pormisc_callback = callback; 397 398 return RT_EOK; 399 } 400 401 void rt_wlan_dev_promisc_handler(struct rt_wlan_device *device, void *data, int len) 402 { 403 rt_wlan_pormisc_callback_t callback; 404 405 if (device == RT_NULL) 406 { 407 return; 408 } 409 410 callback = device->pormisc_callback; 411 412 if (callback != RT_NULL) 413 { 414 callback(device, data, len); 415 } 416 } 417 418 rt_err_t rt_wlan_dev_cfg_filter(struct rt_wlan_device *device, struct rt_wlan_filter *filter) 419 { 420 rt_err_t result = RT_EOK; 421 422 if (device == RT_NULL) 423 { 424 return -RT_EIO; 425 } 426 if (filter == RT_NULL) 427 { 428 return -RT_ERROR; 429 } 430 431 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_FILTER, filter); 432 return result; 433 } 434 435 rt_err_t rt_wlan_dev_set_channel(struct rt_wlan_device *device, int channel) 436 { 437 rt_err_t result = RT_EOK; 438 439 if (device == RT_NULL) 440 { 441 return -RT_EIO; 442 } 443 if (channel < 0) 444 { 445 return -RT_ERROR; 446 } 447 448 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_CHANNEL, &channel); 449 return result; 450 } 451 452 int rt_wlan_dev_get_channel(struct rt_wlan_device *device) 453 { 454 rt_err_t result = RT_EOK; 455 int channel = -1; 456 457 if (device == RT_NULL) 458 { 459 rt_set_errno(-RT_EIO); 460 return -1; 461 } 462 463 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_CHANNEL, &channel); 464 if (result != RT_EOK) 465 { 466 rt_set_errno(result); 467 return -1; 468 } 469 470 return channel; 471 } 472 473 rt_err_t rt_wlan_dev_set_country(struct rt_wlan_device *device, rt_country_code_t country_code) 474 { 475 int result = RT_EOK; 476 477 if (device == RT_NULL) 478 { 479 return -RT_EIO; 480 } 481 482 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_COUNTRY, &country_code); 483 return result; 484 } 485 486 rt_country_code_t rt_wlan_dev_get_country(struct rt_wlan_device *device) 487 { 488 int result = RT_EOK; 489 rt_country_code_t country_code = RT_COUNTRY_UNKNOWN; 490 491 if (device == RT_NULL) 492 { 493 rt_set_errno(-RT_EIO); 494 return RT_COUNTRY_UNKNOWN; 495 } 496 497 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_COUNTRY, &country_code); 498 if (result != RT_EOK) 499 { 500 rt_set_errno(result); 501 return RT_COUNTRY_UNKNOWN; 502 } 503 504 return country_code; 505 } 506 507 rt_err_t rt_wlan_dev_scan(struct rt_wlan_device *device, struct rt_wlan_info *info) 508 { 509 struct rt_scan_info scan_info = { 0 }; 510 struct rt_scan_info *p_scan_info = RT_NULL; 511 rt_err_t result = 0; 512 513 if (device == RT_NULL) 514 { 515 return -RT_EIO; 516 } 517 518 if (info != RT_NULL) 519 { 520 if (info->ssid.len >= RT_WLAN_SSID_MAX_LENGTH) 521 { 522 LOG_E("L:%d ssid is to long", __LINE__); 523 return -RT_EINVAL; 524 } 525 rt_memcpy(&scan_info.ssid, &info->ssid, sizeof(rt_wlan_ssid_t)); 526 rt_memcpy(scan_info.bssid, info->bssid, RT_WLAN_BSSID_MAX_LENGTH); 527 scan_info.channel_min = -1; 528 scan_info.channel_max = -1; 529 p_scan_info = &scan_info; 530 } 531 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SCAN, p_scan_info); 532 return result; 533 } 534 535 rt_err_t rt_wlan_dev_scan_stop(struct rt_wlan_device *device) 536 { 537 rt_err_t result = 0; 538 539 if (device == RT_NULL) 540 { 541 return -RT_EIO; 542 } 543 544 result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SCAN_STOP, RT_NULL); 545 return result; 546 } 547 548 rt_err_t rt_wlan_dev_report_data(struct rt_wlan_device *device, void *buff, int len) 549 { 550 return rt_wlan_dev_transfer_prot(device, buff, len); 551 } 552 553 static rt_err_t _rt_wlan_dev_init(rt_device_t dev) 554 { 555 struct rt_wlan_device *wlan = (struct rt_wlan_device *)dev; 556 rt_err_t result = RT_EOK; 557 558 rt_mutex_init(&wlan->lock, "wlan_dev", RT_IPC_FLAG_FIFO); 559 560 if (wlan->ops->wlan_init) 561 result = wlan->ops->wlan_init(wlan); 562 563 if (result == RT_EOK) 564 { 565 LOG_I("wlan init success"); 566 } 567 else 568 { 569 LOG_I("wlan init failed"); 570 } 571 572 return result; 573 } 574 575 static rt_err_t _rt_wlan_dev_control(rt_device_t dev, int cmd, void *args) 576 { 577 struct rt_wlan_device *wlan = (struct rt_wlan_device *)dev; 578 rt_err_t err = RT_EOK; 579 580 RT_ASSERT(dev != RT_NULL); 581 582 WLAN_DEV_LOCK(wlan); 583 584 switch (cmd) 585 { 586 case RT_WLAN_CMD_MODE: 587 { 588 rt_wlan_mode_t mode = *((rt_wlan_mode_t *)args); 589 590 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_MODE, "RT_WLAN_CMD_MODE"); 591 if (wlan->ops->wlan_mode) 592 err = wlan->ops->wlan_mode(wlan, mode); 593 break; 594 } 595 case RT_WLAN_CMD_SCAN: 596 { 597 struct rt_scan_info *scan_info = args; 598 599 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SCAN, "RT_WLAN_CMD_SCAN"); 600 if (wlan->ops->wlan_scan) 601 err = wlan->ops->wlan_scan(wlan, scan_info); 602 break; 603 } 604 case RT_WLAN_CMD_JOIN: 605 { 606 struct rt_sta_info *sta_info = args; 607 608 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_JOIN, "RT_WLAN_CMD_JOIN"); 609 if (wlan->ops->wlan_join) 610 err = wlan->ops->wlan_join(wlan, sta_info); 611 break; 612 } 613 case RT_WLAN_CMD_SOFTAP: 614 { 615 struct rt_ap_info *ap_info = args; 616 617 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SOFTAP, "RT_WLAN_CMD_SOFTAP"); 618 if (wlan->ops->wlan_softap) 619 err = wlan->ops->wlan_softap(wlan, ap_info); 620 break; 621 } 622 case RT_WLAN_CMD_DISCONNECT: 623 { 624 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_DISCONNECT, "RT_WLAN_CMD_DISCONNECT"); 625 if (wlan->ops->wlan_disconnect) 626 err = wlan->ops->wlan_disconnect(wlan); 627 break; 628 } 629 case RT_WLAN_CMD_AP_STOP: 630 { 631 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_AP_STOP, "RT_WLAN_CMD_AP_STOP"); 632 if (wlan->ops->wlan_ap_stop) 633 err = wlan->ops->wlan_ap_stop(wlan); 634 break; 635 } 636 case RT_WLAN_CMD_AP_DEAUTH: 637 { 638 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_AP_DEAUTH, "RT_WLAN_CMD_AP_DEAUTH"); 639 if (wlan->ops->wlan_ap_deauth) 640 err = wlan->ops->wlan_ap_deauth(wlan, args); 641 break; 642 } 643 case RT_WLAN_CMD_SCAN_STOP: 644 { 645 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SCAN_STOP, "RT_WLAN_CMD_SCAN_STOP"); 646 if (wlan->ops->wlan_scan_stop) 647 err = wlan->ops->wlan_scan_stop(wlan); 648 break; 649 } 650 case RT_WLAN_CMD_GET_RSSI: 651 { 652 int *rssi = args; 653 654 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_RSSI, "RT_WLAN_CMD_GET_RSSI"); 655 if (wlan->ops->wlan_get_rssi) 656 *rssi = wlan->ops->wlan_get_rssi(wlan); 657 break; 658 } 659 case RT_WLAN_CMD_SET_POWERSAVE: 660 { 661 int level = *((int *)args); 662 663 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_POWERSAVE, "RT_WLAN_CMD_SET_POWERSAVE"); 664 if (wlan->ops->wlan_set_powersave) 665 err = wlan->ops->wlan_set_powersave(wlan, level); 666 break; 667 } 668 case RT_WLAN_CMD_GET_POWERSAVE: 669 { 670 int *level = args; 671 672 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_POWERSAVE, "RT_WLAN_CMD_GET_POWERSAVE"); 673 if (wlan->ops->wlan_get_powersave) 674 *level = wlan->ops->wlan_get_powersave(wlan); 675 break; 676 } 677 case RT_WLAN_CMD_CFG_PROMISC: 678 { 679 rt_bool_t start = *((rt_bool_t *)args); 680 681 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_CFG_PROMISC, "RT_WLAN_CMD_CFG_PROMISC"); 682 if (wlan->ops->wlan_cfg_promisc) 683 err = wlan->ops->wlan_cfg_promisc(wlan, start); 684 break; 685 } 686 case RT_WLAN_CMD_CFG_FILTER: 687 { 688 struct rt_wlan_filter *filter = args; 689 690 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_CFG_FILTER, "RT_WLAN_CMD_CFG_FILTER"); 691 if (wlan->ops->wlan_cfg_filter) 692 err = wlan->ops->wlan_cfg_filter(wlan, filter); 693 break; 694 } 695 case RT_WLAN_CMD_SET_CHANNEL: 696 { 697 int channel = *(int *)args; 698 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_CHANNEL, "RT_WLAN_CMD_SET_CHANNEL"); 699 if (wlan->ops->wlan_set_channel) 700 err = wlan->ops->wlan_set_channel(wlan, channel); 701 break; 702 } 703 case RT_WLAN_CMD_GET_CHANNEL: 704 { 705 int *channel = args; 706 707 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_CHANNEL, "RT_WLAN_CMD_GET_CHANNEL"); 708 if (wlan->ops->wlan_get_channel) 709 *channel = wlan->ops->wlan_get_channel(wlan); 710 break; 711 } 712 case RT_WLAN_CMD_SET_COUNTRY: 713 { 714 rt_country_code_t country = *(rt_country_code_t *)args; 715 716 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_COUNTRY, "RT_WLAN_CMD_SET_COUNTRY"); 717 if (wlan->ops->wlan_set_country) 718 err = wlan->ops->wlan_set_country(wlan, country); 719 break; 720 } 721 case RT_WLAN_CMD_GET_COUNTRY: 722 { 723 rt_country_code_t *country = args; 724 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_COUNTRY, "RT_WLAN_CMD_GET_COUNTRY"); 725 if (wlan->ops->wlan_get_country) 726 *country = wlan->ops->wlan_get_country(wlan); 727 break; 728 } 729 case RT_WLAN_CMD_SET_MAC: 730 { 731 rt_uint8_t *mac = args; 732 733 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_MAC, "RT_WLAN_CMD_SET_MAC"); 734 if (wlan->ops->wlan_set_mac) 735 err = wlan->ops->wlan_set_mac(wlan, mac); 736 break; 737 } 738 case RT_WLAN_CMD_GET_MAC: 739 { 740 rt_uint8_t *mac = args; 741 742 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_MAC, "RT_WLAN_CMD_GET_MAC"); 743 if (wlan->ops->wlan_get_mac) 744 err = wlan->ops->wlan_get_mac(wlan, mac); 745 break; 746 } 747 default: 748 LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, -1, "UNKUOWN"); 749 break; 750 } 751 752 WLAN_DEV_UNLOCK(wlan); 753 754 return err; 755 } 756 757 #ifdef RT_USING_DEVICE_OPS 758 const static struct rt_device_ops wlan_ops = 759 { 760 _rt_wlan_dev_init, 761 RT_NULL, 762 RT_NULL, 763 RT_NULL, 764 RT_NULL, 765 _rt_wlan_dev_control 766 }; 767 #endif 768 769 rt_err_t rt_wlan_dev_register(struct rt_wlan_device *wlan, const char *name, const struct rt_wlan_dev_ops *ops, rt_uint32_t flag, void *user_data) 770 { 771 rt_err_t err = RT_EOK; 772 773 if ((wlan == RT_NULL) || (name == RT_NULL) || (ops == RT_NULL)) 774 { 775 LOG_E("F:%s L:%d parameter Wrongful", __FUNCTION__, __LINE__); 776 return RT_NULL; 777 } 778 779 rt_memset(wlan, 0, sizeof(struct rt_wlan_device)); 780 781 #ifdef RT_USING_DEVICE_OPS 782 wlan->device.ops = &wlan_ops; 783 #else 784 wlan->device.init = _rt_wlan_dev_init; 785 wlan->device.open = RT_NULL; 786 wlan->device.close = RT_NULL; 787 wlan->device.read = RT_NULL; 788 wlan->device.write = RT_NULL; 789 wlan->device.control = _rt_wlan_dev_control; 790 #endif 791 792 wlan->device.user_data = RT_NULL; 793 794 wlan->device.type = RT_Device_Class_NetIf; 795 796 wlan->ops = ops; 797 wlan->user_data = user_data; 798 799 wlan->flags = flag; 800 err = rt_device_register(&wlan->device, name, RT_DEVICE_FLAG_RDWR); 801 802 LOG_D("F:%s L:%d run", __FUNCTION__, __LINE__); 803 804 return err; 805 } 806