drivers/net/wireless/rockchip_wlan/combo_mt66xx/mt6628/wlan/os/linux/gl_p2p_kal.c

   1 /*
   2 ** $Id: @(#) gl_p2p_cfg80211.c@@
   3 */
   4
   5 /*! \file   gl_p2p_kal.c
   6     \brief
   7
   8 */
   9
  10
  11
  12
  13 /*******************************************************************************
  14 *                         C O M P I L E R   F L A G S
  15 ********************************************************************************
  16 */
  17
  18 /*******************************************************************************
  19 *                    E X T E R N A L   R E F E R E N C E S
  20 ********************************************************************************
  21 */
  22 #include "net/cfg80211.h"
  23 #include "precomp.h"
  24
  25 extern BOOLEAN
  26 wextSrchDesiredWPAIE (
  27     IN  PUINT_8         pucIEStart,
  28     IN  INT_32          i4TotalIeLen,
  29     IN  UINT_8          ucDesiredElemId,
  30     OUT PUINT_8         *ppucDesiredIE
  31     );
  32
  33 #if CFG_SUPPORT_WPS
  34 extern BOOLEAN
  35 wextSrchDesiredWPSIE (
  36     IN PUINT_8 pucIEStart,
  37     IN INT_32 i4TotalIeLen,
  38     IN UINT_8 ucDesiredElemId,
  39     OUT PUINT_8 *ppucDesiredIE
  40     );
  41 #endif
  42
  43 /*******************************************************************************
  44 *                              C O N S T A N T S
  45 ********************************************************************************
  46 */
  47
  48 /*******************************************************************************
  49 *                             D A T A   T Y P E S
  50 ********************************************************************************
  51 */
  52
  53 /*******************************************************************************
  54 *                            P U B L I C   D A T A
  55 ********************************************************************************
  56 */
  57
  58 /*******************************************************************************
  59 *                           P R I V A T E   D A T A
  60 ********************************************************************************
  61 */
  62
  63 /*******************************************************************************
  64 *                                 M A C R O S
  65 ********************************************************************************
  66 */
  67
  68 /*******************************************************************************
  69 *                   F U N C T I O N   D E C L A R A T I O N S
  70 ********************************************************************************
  71 */
  72 BOOLEAN
  73 kalP2pFuncGetChannelType(
  74     IN ENUM_CHNL_EXT_T rChnlSco,
  75     OUT enum nl80211_channel_type *channel_type
  76     );
  77
  78
  79 struct ieee80211_channel *
  80 kalP2pFuncGetChannelEntry(
  81     IN P_GL_P2P_INFO_T prP2pInfo,
  82     IN P_RF_CHANNEL_INFO_T prChannelInfo
  83     );
  84
  85
  86 /*******************************************************************************
  87 *                              F U N C T I O N S
  88 ********************************************************************************
  89 */
  90
  91 /*----------------------------------------------------------------------------*/
  92 /*!
  93 * \brief to retrieve Wi-Fi Direct state from glue layer
  94 *
  95 * \param[in]
  96 *           prGlueInfo
  97 *           rPeerAddr
  98 * \return
  99 *           ENUM_BOW_DEVICE_STATE
 100 */
 101 /*----------------------------------------------------------------------------*/
 102 ENUM_PARAM_MEDIA_STATE_T
 103 kalP2PGetState (
 104     IN P_GLUE_INFO_T        prGlueInfo
 105     )
 106 {
 107     ASSERT(prGlueInfo);
 108
 109     return prGlueInfo->prP2PInfo->eState;
 110 } /* end of kalP2PGetState() */
 111
 112
 113 /*----------------------------------------------------------------------------*/
 114 /*!
 115 * \brief to update the assoc req to p2p
 116 *
 117 * \param[in]
 118 *           prGlueInfo
 119 *           pucFrameBody
 120 *           u4FrameBodyLen
 121 *           fgReassocRequest
 122 * \return
 123 *           none
 124 */
 125 /*----------------------------------------------------------------------------*/
 126 VOID
 127 kalP2PUpdateAssocInfo (
 128     IN P_GLUE_INFO_T    prGlueInfo,
 129     IN PUINT_8          pucFrameBody,
 130     IN UINT_32          u4FrameBodyLen,
 131     IN BOOLEAN          fgReassocRequest
 132     )
 133 {
 134     union iwreq_data wrqu;
 135     unsigned char *pucExtraInfo = NULL;
 136     unsigned char *pucDesiredIE = NULL;
 137 //    unsigned char aucExtraInfoBuf[200];
 138     PUINT_8             cp;
 139
 140     memset(&wrqu, 0, sizeof(wrqu));
 141
 142     if (fgReassocRequest) {
 143         if (u4FrameBodyLen < 15) {
 144             /*
 145             printk(KERN_WARNING "frameBodyLen too short:%ld\n", frameBodyLen);
 146             */
 147             return;
 148         }
 149     }
 150     else {
 151         if (u4FrameBodyLen < 9) {
 152             /*
 153             printk(KERN_WARNING "frameBodyLen too short:%ld\n", frameBodyLen);
 154             */
 155             return;
 156         }
 157     }
 158
 159     cp = pucFrameBody;
 160
 161     if (fgReassocRequest) {
 162         /* Capability information field 2 */
 163         /* Listen interval field 2*/
 164         /* Current AP address 6 */
 165         cp += 10;
 166         u4FrameBodyLen -= 10;
 167     }
 168     else {
 169         /* Capability information field 2 */
 170         /* Listen interval field 2*/
 171         cp += 4;
 172         u4FrameBodyLen -= 4;
 173     }
 174
 175     /* do supplicant a favor, parse to the start of WPA/RSN IE */
 176     if (wextSrchDesiredWPSIE(cp, u4FrameBodyLen, 0xDD, &pucDesiredIE)) {
 177         //printk("wextSrchDesiredWPSIE!!\n");
 178         /* WPS IE found */
 179     }
 180     else if (wextSrchDesiredWPAIE(cp, u4FrameBodyLen, 0x30, &pucDesiredIE)) {
 181         //printk("wextSrchDesiredWPAIE!!\n");
 182         /* RSN IE found */
 183     }
 184     else if (wextSrchDesiredWPAIE(cp, u4FrameBodyLen, 0xDD, &pucDesiredIE)) {
 185         //printk("wextSrchDesiredWPAIE!!\n");
 186         /* WPA IE found */
 187     }
 188     else {
 189         /* no WPA/RSN IE found, skip this event */
 190         goto skip_indicate_event;
 191     }
 192
 193      /* IWEVASSOCREQIE, indicate binary string */
 194     pucExtraInfo = pucDesiredIE;
 195     wrqu.data.length = pucDesiredIE[1] + 2;
 196
 197     /* Send event to user space */
 198     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler, IWEVASSOCREQIE, &wrqu, pucExtraInfo);
 199
 200 skip_indicate_event:
 201     return;
 202
 203 }
 204
 205
 206 /*----------------------------------------------------------------------------*/
 207 /*!
 208 * \brief to set Wi-Fi Direct state in glue layer
 209 *
 210 * \param[in]
 211 *           prGlueInfo
 212 *           eBowState
 213 *           rPeerAddr
 214 * \return
 215 *           none
 216 */
 217 /*----------------------------------------------------------------------------*/
 218 VOID
 219 kalP2PSetState (
 220     IN P_GLUE_INFO_T            prGlueInfo,
 221     IN ENUM_PARAM_MEDIA_STATE_T eState,
 222     IN PARAM_MAC_ADDRESS        rPeerAddr,
 223     IN UINT_8                   ucRole
 224     )
 225 {
 226     union iwreq_data evt;
 227     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 228
 229     ASSERT(prGlueInfo);
 230
 231     memset(&evt, 0, sizeof(evt));
 232
 233     if(eState == PARAM_MEDIA_STATE_CONNECTED) {
 234         prGlueInfo->prP2PInfo->eState = PARAM_MEDIA_STATE_CONNECTED;
 235
 236         snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_STA_CONNECT="MACSTR, MAC2STR(rPeerAddr));
 237         evt.data.length = strlen(aucBuffer);
 238
 239         /* indicate in IWECUSTOM event */
 240         wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 241                 IWEVCUSTOM,
 242                 &evt,
 243                 aucBuffer);
 244
 245     }
 246     else if(eState == PARAM_MEDIA_STATE_DISCONNECTED) {
 247         snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_STA_DISCONNECT="MACSTR, MAC2STR(rPeerAddr));
 248         evt.data.length = strlen(aucBuffer);
 249
 250         /* indicate in IWECUSTOM event */
 251         wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 252                 IWEVCUSTOM,
 253                 &evt,
 254                 aucBuffer);
 255     }
 256     else {
 257         ASSERT(0);
 258     }
 259
 260     return;
 261 } /* end of kalP2PSetState() */
 262
 263
 264 /*----------------------------------------------------------------------------*/
 265 /*!
 266 * \brief to retrieve Wi-Fi Direct operating frequency
 267 *
 268 * \param[in]
 269 *           prGlueInfo
 270 *
 271 * \return
 272 *           in unit of KHz
 273 */
 274 /*----------------------------------------------------------------------------*/
 275 UINT_32
 276 kalP2PGetFreqInKHz(
 277     IN P_GLUE_INFO_T            prGlueInfo
 278     )
 279 {
 280     ASSERT(prGlueInfo);
 281
 282     return prGlueInfo->prP2PInfo->u4FreqInKHz;
 283 } /* end of kalP2PGetFreqInKHz() */
 284
 285
 286 /*----------------------------------------------------------------------------*/
 287 /*!
 288 * \brief to retrieve Bluetooth-over-Wi-Fi role
 289 *
 290 * \param[in]
 291 *           prGlueInfo
 292 *
 293 * \return
 294 *           0: P2P Device
 295 *           1: Group Client
 296 *           2: Group Owner
 297 */
 298 /*----------------------------------------------------------------------------*/
 299 UINT_8
 300 kalP2PGetRole(
 301     IN P_GLUE_INFO_T        prGlueInfo
 302     )
 303 {
 304     ASSERT(prGlueInfo);
 305
 306     return prGlueInfo->prP2PInfo->ucRole;
 307 } /* end of kalP2PGetRole() */
 308
 309
 310 /*----------------------------------------------------------------------------*/
 311 /*!
 312 * \brief to set Wi-Fi Direct role
 313 *
 314 * \param[in]
 315 *           prGlueInfo
 316 *           ucResult
 317 *                   0: successful
 318 *                   1: error
 319 *           ucRole
 320 *                   0: P2P Device
 321 *                   1: Group Client
 322 *                   2: Group Owner
 323 *
 324 * \return
 325 *           none
 326 */
 327 /*----------------------------------------------------------------------------*/
 328 VOID
 329 kalP2PSetRole(
 330     IN P_GLUE_INFO_T    prGlueInfo,
 331     IN UINT_8           ucResult,
 332     IN PUINT_8          pucSSID,
 333     IN UINT_8           ucSSIDLen,
 334     IN UINT_8           ucRole
 335     )
 336 {
 337     union iwreq_data evt;
 338     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 339
 340     ASSERT(prGlueInfo);
 341     ASSERT(ucRole <= 2);
 342
 343     memset(&evt, 0, sizeof(evt));
 344
 345     if(ucResult == 0) {
 346         prGlueInfo->prP2PInfo->ucRole = ucRole;
 347     }
 348
 349     if (pucSSID)
 350         snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_FORMATION_RST=%d%d%d%c%c", ucResult, ucRole, 1/* persistence or not */, pucSSID[7], pucSSID[8]);
 351     else
 352         snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_FORMATION_RST=%d%d%d%c%c", ucResult, ucRole, 1/* persistence or not */, '0', '0');
 353
 354     evt.data.length = strlen(aucBuffer);
 355
 356     //if (pucSSID)
 357     //    printk("P2P GO SSID DIRECT-%c%c\n", pucSSID[7], pucSSID[8]);
 358
 359     /* indicate in IWECUSTOM event */
 360     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 361             IWEVCUSTOM,
 362             &evt,
 363             aucBuffer);
 364
 365     return;
 366 } /* end of kalP2PSetRole() */
 367
 368
 369 /*----------------------------------------------------------------------------*/
 370 /*!
 371 * \brief to set the cipher for p2p
 372 *
 373 * \param[in]
 374 *           prGlueInfo
 375 *           u4Cipher
 376 *
 377 * \return
 378 *           none
 379 */
 380 /*----------------------------------------------------------------------------*/
 381 VOID
 382 kalP2PSetCipher(
 383     IN P_GLUE_INFO_T    prGlueInfo,
 384     IN UINT_32          u4Cipher
 385     )
 386 {
 387     ASSERT(prGlueInfo);
 388     ASSERT(prGlueInfo->prP2PInfo);
 389
 390     prGlueInfo->prP2PInfo->u4CipherPairwise = u4Cipher;
 391
 392     return;
 393 }
 394
 395
 396 /*----------------------------------------------------------------------------*/
 397 /*!
 398 * \brief to get the cipher, return for cipher is ccmp
 399 *
 400 * \param[in]
 401 *           prGlueInfo
 402 *
 403 * \return
 404 *           TRUE: cipher is ccmp
 405 *           FALSE: cipher is none
 406 */
 407 /*----------------------------------------------------------------------------*/
 408 BOOLEAN
 409 kalP2PGetCipher (
 410     IN P_GLUE_INFO_T    prGlueInfo
 411     )
 412 {
 413     ASSERT(prGlueInfo);
 414     ASSERT(prGlueInfo->prP2PInfo);
 415
 416     if (prGlueInfo->prP2PInfo->u4CipherPairwise == IW_AUTH_CIPHER_CCMP)
 417         return TRUE;
 418
 419     if (prGlueInfo->prP2PInfo->u4CipherPairwise == IW_AUTH_CIPHER_TKIP)
 420         return TRUE;
 421
 422     return FALSE;
 423 }
 424
 425 BOOLEAN
 426 kalP2PGetCcmpCipher (
 427     IN P_GLUE_INFO_T    prGlueInfo
 428     )
 429 {
 430     ASSERT(prGlueInfo);
 431     ASSERT(prGlueInfo->prP2PInfo);
 432
 433     if (prGlueInfo->prP2PInfo->u4CipherPairwise == IW_AUTH_CIPHER_CCMP)
 434         return TRUE;
 435
 436     if (prGlueInfo->prP2PInfo->u4CipherPairwise == IW_AUTH_CIPHER_TKIP)
 437         return FALSE;
 438
 439     return FALSE;
 440 }
 441
 442
 443 BOOLEAN
 444 kalP2PGetTkipCipher (
 445     IN P_GLUE_INFO_T    prGlueInfo
 446     )
 447 {
 448     ASSERT(prGlueInfo);
 449     ASSERT(prGlueInfo->prP2PInfo);
 450
 451     if (prGlueInfo->prP2PInfo->u4CipherPairwise == IW_AUTH_CIPHER_CCMP)
 452         return FALSE;
 453
 454     if (prGlueInfo->prP2PInfo->u4CipherPairwise == IW_AUTH_CIPHER_TKIP)
 455         return TRUE;
 456
 457     return FALSE;
 458 }
 459
 460 /*----------------------------------------------------------------------------*/
 461 /*!
 462 * \brief to set the status of WSC
 463 *
 464 * \param[in]
 465 *           prGlueInfo
 466 *
 467 * \return
 468 */
 469 /*----------------------------------------------------------------------------*/
 470 VOID
 471 kalP2PSetWscMode (
 472     IN P_GLUE_INFO_T    prGlueInfo,
 473     IN UINT_8           ucWscMode
 474     )
 475 {
 476     ASSERT(prGlueInfo);
 477     ASSERT(prGlueInfo->prP2PInfo);
 478
 479     prGlueInfo->prP2PInfo->ucWSCRunning = ucWscMode;
 480 }
 481
 482
 483 /*----------------------------------------------------------------------------*/
 484 /*!
 485 * \brief to get the status of WSC
 486 *
 487 * \param[in]
 488 *           prGlueInfo
 489 *
 490 * \return
 491 */
 492 /*----------------------------------------------------------------------------*/
 493 UINT_8
 494 kalP2PGetWscMode (
 495     IN P_GLUE_INFO_T    prGlueInfo
 496     )
 497 {
 498     ASSERT(prGlueInfo);
 499     ASSERT(prGlueInfo->prP2PInfo);
 500
 501     return (prGlueInfo->prP2PInfo->ucWSCRunning);
 502 }
 503
 504
 505 /*----------------------------------------------------------------------------*/
 506 /*!
 507 * \brief to get the wsc ie length
 508 *
 509 * \param[in]
 510 *           prGlueInfo
 511 *           ucType : 0 for beacon, 1 for probe req, 2 for probe resp
 512 *
 513 * \return
 514 *           The WSC IE length
 515 */
 516 /*----------------------------------------------------------------------------*/
 517 UINT_16
 518 kalP2PCalWSC_IELen (
 519     IN P_GLUE_INFO_T    prGlueInfo,
 520     IN UINT_8           ucType
 521     )
 522 {
 523     ASSERT(prGlueInfo);
 524
 525     ASSERT(ucType < 3);
 526
 527     return prGlueInfo->prP2PInfo->u2WSCIELen[ucType];
 528 }
 529
 530
 531 /*----------------------------------------------------------------------------*/
 532 /*!
 533 * \brief to copy the wsc ie setting from p2p supplicant
 534 *
 535 * \param[in]
 536 *           prGlueInfo
 537 *
 538 * \return
 539 *           The WPS IE length
 540 */
 541 /*----------------------------------------------------------------------------*/
 542 VOID
 543 kalP2PGenWSC_IE (
 544     IN P_GLUE_INFO_T    prGlueInfo,
 545     IN UINT_8           ucType,
 546     IN PUINT_8          pucBuffer
 547     )
 548 {
 549     P_GL_P2P_INFO_T prGlP2pInfo = (P_GL_P2P_INFO_T)NULL;
 550
 551     do {
 552         if ((prGlueInfo == NULL) ||
 553                 (ucType >= 3) ||
 554                 (pucBuffer == NULL)) {
 555             break;
 556         }
 557
 558
 559         prGlP2pInfo = prGlueInfo->prP2PInfo;
 560
 561         kalMemCopy(pucBuffer, prGlP2pInfo->aucWSCIE[ucType], prGlP2pInfo->u2WSCIELen[ucType]);
 562
 563     } while (FALSE);
 564
 565     return;
 566 }
 567
 568
 569 VOID
 570 kalP2PUpdateWSC_IE (
 571     IN P_GLUE_INFO_T prGlueInfo,
 572     IN UINT_8 ucType,
 573     IN PUINT_8 pucBuffer,
 574     IN UINT_16 u2BufferLength
 575     )
 576 {
 577     P_GL_P2P_INFO_T prGlP2pInfo = (P_GL_P2P_INFO_T)NULL;
 578
 579     do {
 580         if ((prGlueInfo == NULL) ||
 581                 (ucType >= 3) ||
 582                 ((u2BufferLength > 0) && (pucBuffer == NULL))) {
 583             break;
 584         }
 585
 586
 587         if (u2BufferLength > 400) {
 588             DBGLOG(P2P, ERROR, ("Buffer length is not enough, GLUE only 400 bytes but %d received\n", u2BufferLength));
 589             ASSERT(FALSE);
 590             break;
 591         }
 592
 593
 594         prGlP2pInfo = prGlueInfo->prP2PInfo;
 595
 596         kalMemCopy(prGlP2pInfo->aucWSCIE[ucType], pucBuffer, u2BufferLength);
 597
 598         prGlP2pInfo->u2WSCIELen[ucType] = u2BufferLength;
 599
 600
 601     } while (FALSE);
 602
 603     return;
 604 } /* kalP2PUpdateWSC_IE */
 605
 606
 607
 608 /*----------------------------------------------------------------------------*/
 609 /*!
 610 * \brief indicate an event to supplicant for device connection request
 611 *
 612 * \param[in] prGlueInfo Pointer of GLUE_INFO_T
 613 *
 614 * \retval none
 615 */
 616 /*----------------------------------------------------------------------------*/
 617 VOID
 618 kalP2PIndicateConnReq(
 619     IN P_GLUE_INFO_T        prGlueInfo,
 620     IN PUINT_8              pucDevName,
 621     IN INT_32               u4NameLength,
 622     IN PARAM_MAC_ADDRESS    rPeerAddr,
 623     IN UINT_8               ucDevType, /* 0: P2P Device / 1: GC / 2: GO */
 624     IN INT_32               i4ConfigMethod,
 625     IN INT_32               i4ActiveConfigMethod
 626     )
 627 {
 628     union iwreq_data evt;
 629     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 630
 631     ASSERT(prGlueInfo);
 632
 633     /* buffer peer information for later IOC_P2P_GET_REQ_DEVICE_INFO access */
 634     prGlueInfo->prP2PInfo->u4ConnReqNameLength = u4NameLength > 32 ? 32 : u4NameLength;
 635     kalMemCopy(prGlueInfo->prP2PInfo->aucConnReqDevName,
 636             pucDevName,
 637             prGlueInfo->prP2PInfo->u4ConnReqNameLength);
 638     COPY_MAC_ADDR(prGlueInfo->prP2PInfo->rConnReqPeerAddr, rPeerAddr);
 639     prGlueInfo->prP2PInfo->ucConnReqDevType = ucDevType;
 640     prGlueInfo->prP2PInfo->i4ConnReqConfigMethod = i4ConfigMethod;
 641     prGlueInfo->prP2PInfo->i4ConnReqActiveConfigMethod = i4ActiveConfigMethod;
 642
 643     // prepare event structure
 644     memset(&evt, 0, sizeof(evt));
 645
 646     snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_DVC_REQ");
 647     evt.data.length = strlen(aucBuffer);
 648
 649     /* indicate in IWEVCUSTOM event */
 650     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 651             IWEVCUSTOM,
 652             &evt,
 653             aucBuffer);
 654
 655     return;
 656 } /* end of kalP2PIndicateConnReq() */
 657
 658
 659 /*----------------------------------------------------------------------------*/
 660 /*!
 661 * \brief Indicate an event to supplicant for device connection request from other device.
 662 *
 663 * \param[in] prGlueInfo Pointer of GLUE_INFO_T
 664 * \param[in] pucGroupBssid  Only valid when invitation Type equals to 0.
 665 *
 666 * \retval none
 667 */
 668 /*----------------------------------------------------------------------------*/
 669 VOID
 670 kalP2PInvitationIndication (
 671     IN P_GLUE_INFO_T prGlueInfo,
 672     IN P_P2P_DEVICE_DESC_T prP2pDevDesc,
 673     IN PUINT_8 pucSsid,
 674     IN UINT_8 ucSsidLen,
 675     IN UINT_8 ucOperatingChnl,
 676     IN UINT_8 ucInvitationType,
 677     IN PUINT_8 pucGroupBssid
 678     )
 679 {
 680 #if 1
 681     union iwreq_data evt;
 682     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 683
 684     ASSERT(prGlueInfo);
 685
 686     /* buffer peer information for later IOC_P2P_GET_STRUCT access */
 687     prGlueInfo->prP2PInfo->u4ConnReqNameLength = (UINT_32)((prP2pDevDesc->u2NameLength > 32)? 32 : prP2pDevDesc->u2NameLength);
 688     kalMemCopy(prGlueInfo->prP2PInfo->aucConnReqDevName,
 689                     prP2pDevDesc->aucName,
 690                     prGlueInfo->prP2PInfo->u4ConnReqNameLength);
 691     COPY_MAC_ADDR(prGlueInfo->prP2PInfo->rConnReqPeerAddr, prP2pDevDesc->aucDeviceAddr);
 692     COPY_MAC_ADDR(prGlueInfo->prP2PInfo->rConnReqGroupAddr, pucGroupBssid);
 693     prGlueInfo->prP2PInfo->i4ConnReqConfigMethod = (INT_32)(prP2pDevDesc->u2ConfigMethod);
 694     prGlueInfo->prP2PInfo->ucOperatingChnl = ucOperatingChnl;
 695     prGlueInfo->prP2PInfo->ucInvitationType = ucInvitationType;
 696
 697     // prepare event structure
 698     memset(&evt, 0, sizeof(evt));
 699
 700     snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_INV_INDICATE");
 701     evt.data.length = strlen(aucBuffer);
 702
 703     /* indicate in IWEVCUSTOM event */
 704     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 705             IWEVCUSTOM,
 706             &evt,
 707             aucBuffer);
 708     return;
 709
 710 #else
 711     P_MSG_P2P_CONNECTION_REQUEST_T prP2pConnReq = (P_MSG_P2P_CONNECTION_REQUEST_T)NULL;
 712     P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
 713     P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
 714
 715     do {
 716         ASSERT_BREAK((prGlueInfo != NULL) && (prP2pDevDesc != NULL));
 717
 718
 719         // Not a real solution
 720
 721         prP2pSpecificBssInfo = prGlueInfo->prAdapter->rWifiVar.prP2pSpecificBssInfo;
 722         prP2pConnSettings = prGlueInfo->prAdapter->rWifiVar.prP2PConnSettings;
 723
 724         prP2pConnReq = (P_MSG_P2P_CONNECTION_REQUEST_T)cnmMemAlloc(prGlueInfo->prAdapter,
 725                                                                                 RAM_TYPE_MSG,
 726                                                                                 sizeof(MSG_P2P_CONNECTION_REQUEST_T));
 727
 728         if (prP2pConnReq == NULL) {
 729             break;
 730         }
 731
 732
 733         kalMemZero(prP2pConnReq, sizeof(MSG_P2P_CONNECTION_REQUEST_T));
 734
 735         prP2pConnReq->rMsgHdr.eMsgId = MID_MNY_P2P_CONNECTION_REQ;
 736
 737         prP2pConnReq->eFormationPolicy = ENUM_P2P_FORMATION_POLICY_AUTO;
 738
 739         COPY_MAC_ADDR(prP2pConnReq->aucDeviceID, prP2pDevDesc->aucDeviceAddr);
 740
 741         prP2pConnReq->u2ConfigMethod = prP2pDevDesc->u2ConfigMethod;
 742
 743         if (ucInvitationType == P2P_INVITATION_TYPE_INVITATION) {
 744             prP2pConnReq->fgIsPersistentGroup = FALSE;
 745             prP2pConnReq->fgIsTobeGO = FALSE;
 746
 747         }
 748
 749         else if (ucInvitationType == P2P_INVITATION_TYPE_REINVOKE) {
 750             DBGLOG(P2P, TRACE, ("Re-invoke Persistent Group\n"));
 751             prP2pConnReq->fgIsPersistentGroup = TRUE;
 752             prP2pConnReq->fgIsTobeGO = (prGlueInfo->prP2PInfo->ucRole == 2)?TRUE:FALSE;
 753
 754         }
 755
 756
 757         p2pFsmRunEventDeviceDiscoveryAbort(prGlueInfo->prAdapter, NULL);
 758
 759         if (ucOperatingChnl != 0) {
 760             prP2pSpecificBssInfo->ucPreferredChannel = ucOperatingChnl;
 761         }
 762
 763         if ((ucSsidLen < 32) && (pucSsid != NULL)) {
 764             COPY_SSID(prP2pConnSettings->aucSSID,
 765                             prP2pConnSettings->ucSSIDLen,
 766                             pucSsid,
 767                             ucSsidLen);
 768         }
 769
 770         mboxSendMsg(prGlueInfo->prAdapter,
 771                         MBOX_ID_0,
 772                         (P_MSG_HDR_T)prP2pConnReq,
 773                         MSG_SEND_METHOD_BUF);
 774
 775
 776
 777     } while (FALSE);
 778
 779     // frog add.
 780     // TODO: Invitation Indication
 781
 782     return;
 783 #endif
 784
 785 } /* kalP2PInvitationIndication */
 786
 787
 788 /*----------------------------------------------------------------------------*/
 789 /*!
 790 * \brief Indicate an status to supplicant for device invitation status.
 791 *
 792 * \param[in] prGlueInfo Pointer of GLUE_INFO_T
 793 *
 794 * \retval none
 795 */
 796 /*----------------------------------------------------------------------------*/
 797 VOID
 798 kalP2PInvitationStatus (
 799     IN P_GLUE_INFO_T prGlueInfo,
 800     IN UINT_32       u4InvStatus
 801     )
 802 {
 803     union iwreq_data evt;
 804     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 805
 806     ASSERT(prGlueInfo);
 807
 808     /* buffer peer information for later IOC_P2P_GET_STRUCT access */
 809     prGlueInfo->prP2PInfo->u4InvStatus = u4InvStatus;
 810
 811     // prepare event structure
 812     memset(&evt, 0, sizeof(evt));
 813
 814     snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_INV_STATUS");
 815     evt.data.length = strlen(aucBuffer);
 816
 817     /* indicate in IWEVCUSTOM event */
 818     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 819             IWEVCUSTOM,
 820             &evt,
 821             aucBuffer);
 822
 823     return;
 824 } /* kalP2PInvitationStatus */
 825
 826 /*----------------------------------------------------------------------------*/
 827 /*!
 828 * \brief Indicate an event to supplicant for Service Discovery request from other device.
 829 *
 830 * \param[in] prGlueInfo Pointer of GLUE_INFO_T
 831 *
 832 * \retval none
 833 */
 834 /*----------------------------------------------------------------------------*/
 835 VOID
 836 kalP2PIndicateSDRequest(
 837     IN P_GLUE_INFO_T        prGlueInfo,
 838     IN PARAM_MAC_ADDRESS    rPeerAddr,
 839     IN UINT_8 ucSeqNum
 840     )
 841 {
 842     union iwreq_data evt;
 843     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 844
 845     ASSERT(prGlueInfo);
 846
 847     memset(&evt, 0, sizeof(evt));
 848
 849     snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_SD_REQ %d", ucSeqNum);
 850     evt.data.length = strlen(aucBuffer);
 851
 852     /* indicate IWEVP2PSDREQ event */
 853     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 854             IWEVCUSTOM,
 855             &evt,
 856             aucBuffer);
 857
 858     return;
 859 } /* end of kalP2PIndicateSDRequest() */
 860
 861
 862 /*----------------------------------------------------------------------------*/
 863 /*!
 864 * \brief Indicate an event to supplicant for Service Discovery response
 865 *         from other device.
 866 *
 867 * \param[in] prGlueInfo Pointer of GLUE_INFO_T
 868 *
 869 * \retval none
 870 */
 871 /*----------------------------------------------------------------------------*/
 872 void
 873 kalP2PIndicateSDResponse(
 874     IN P_GLUE_INFO_T        prGlueInfo,
 875     IN PARAM_MAC_ADDRESS    rPeerAddr,
 876     IN UINT_8 ucSeqNum
 877     )
 878 {
 879     union iwreq_data evt;
 880     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 881
 882     ASSERT(prGlueInfo);
 883
 884     memset(&evt, 0, sizeof(evt));
 885
 886     snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_SD_RESP %d", ucSeqNum);
 887     evt.data.length = strlen(aucBuffer);
 888
 889     /* indicate IWEVP2PSDREQ event */
 890     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 891             IWEVCUSTOM,
 892             &evt,
 893             aucBuffer);
 894
 895     return;
 896 } /* end of kalP2PIndicateSDResponse() */
 897
 898
 899 /*----------------------------------------------------------------------------*/
 900 /*!
 901 * \brief Indicate an event to supplicant for Service Discovery TX Done
 902 *         from other device.
 903 *
 904 * \param[in] prGlueInfo Pointer of GLUE_INFO_T
 905 * \param[in] ucSeqNum   Sequence number of the frame
 906 * \param[in] ucStatus   Status code for TX
 907 *
 908 * \retval none
 909 */
 910 /*----------------------------------------------------------------------------*/
 911 VOID
 912 kalP2PIndicateTXDone(
 913     IN P_GLUE_INFO_T        prGlueInfo,
 914     IN UINT_8               ucSeqNum,
 915     IN UINT_8               ucStatus
 916     )
 917 {
 918     union iwreq_data evt;
 919     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 920
 921     ASSERT(prGlueInfo);
 922
 923     memset(&evt, 0, sizeof(evt));
 924
 925     snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_SD_XMITTED: %d %d", ucSeqNum, ucStatus);
 926     evt.data.length = strlen(aucBuffer);
 927
 928     /* indicate IWEVP2PSDREQ event */
 929     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 930             IWEVCUSTOM,
 931             &evt,
 932             aucBuffer);
 933
 934     return;
 935 } /* end of kalP2PIndicateSDResponse() */
 936
 937
 938 struct net_device*
 939 kalP2PGetDevHdlr(
 940     P_GLUE_INFO_T prGlueInfo
 941     )
 942 {
 943     ASSERT(prGlueInfo);
 944     ASSERT(prGlueInfo->prP2PInfo);
 945     return prGlueInfo->prP2PInfo->prDevHandler;
 946 }
 947
 948 #if CFG_SUPPORT_ANTI_PIRACY
 949 /*----------------------------------------------------------------------------*/
 950 /*!
 951 * \brief
 952 *
 953 * \param[in] prAdapter  Pointer of ADAPTER_T
 954 *
 955 * \return none
 956 */
 957 /*----------------------------------------------------------------------------*/
 958 VOID
 959 kalP2PIndicateSecCheckRsp (
 960     IN P_GLUE_INFO_T prGlueInfo,
 961     IN PUINT_8       pucRsp,
 962     IN UINT_16       u2RspLen
 963     )
 964 {
 965     union iwreq_data evt;
 966     UINT_8 aucBuffer[IW_CUSTOM_MAX];
 967
 968     ASSERT(prGlueInfo);
 969
 970     memset(&evt, 0, sizeof(evt));
 971     snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_SEC_CHECK_RSP=");
 972
 973     kalMemCopy(prGlueInfo->prP2PInfo->aucSecCheckRsp, pucRsp, u2RspLen);
 974     evt.data.length = strlen(aucBuffer);
 975
 976 #if DBG
 977     DBGLOG_MEM8(SEC, LOUD, prGlueInfo->prP2PInfo->aucSecCheckRsp, u2RspLen);
 978 #endif
 979     /* indicate in IWECUSTOM event */
 980     wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
 981             IWEVCUSTOM,
 982             &evt,
 983             aucBuffer);
 984     return;
 985 } /* p2pFsmRunEventRxDisassociation */
 986 #endif
 987
 988
 989 /*----------------------------------------------------------------------------*/
 990 /*!
 991 * \brief
 992 *
 993 * \param[in] prAdapter  Pointer of ADAPTER_T
 994 *
 995 * \return none
 996 */
 997 /*----------------------------------------------------------------------------*/
 998 VOID
 999 kalGetChnlList(
1000     IN P_GLUE_INFO_T           prGlueInfo,
1001     IN ENUM_BAND_T             eSpecificBand,
1002     IN UINT_8                  ucMaxChannelNum,
1003     IN PUINT_8                 pucNumOfChannel,
1004     IN P_RF_CHANNEL_INFO_T     paucChannelList
1005     )
1006 {
1007     rlmDomainGetChnlList(prGlueInfo->prAdapter,
1008                               eSpecificBand,
1009                               ucMaxChannelNum,
1010                               pucNumOfChannel,
1011                               paucChannelList);
1012 } /* kalGetChnlList */
1013
1014 //////////////////////////////////////ICS SUPPORT//////////////////////////////////////
1015
1016 VOID
1017 kalP2PIndicateChannelReady (
1018     IN P_GLUE_INFO_T prGlueInfo,
1019     IN UINT_64 u8SeqNum,
1020     IN UINT_32 u4ChannelNum,
1021     IN ENUM_BAND_T eBand,
1022     IN ENUM_CHNL_EXT_T eSco,
1023     IN UINT_32 u4Duration
1024     )
1025 {
1026     struct ieee80211_channel *prIEEE80211ChnlStruct = (struct ieee80211_channel *)NULL;
1027     RF_CHANNEL_INFO_T rChannelInfo;
1028     enum nl80211_channel_type eChnlType = NL80211_CHAN_NO_HT;
1029
1030     do {
1031         if (prGlueInfo == NULL) {
1032             break;
1033         }
1034
1035
1036         kalMemZero(&rChannelInfo, sizeof(RF_CHANNEL_INFO_T));
1037
1038         rChannelInfo.ucChannelNum = u4ChannelNum;
1039         rChannelInfo.eBand = eBand;
1040
1041         prIEEE80211ChnlStruct = kalP2pFuncGetChannelEntry(prGlueInfo->prP2PInfo, &rChannelInfo);
1042
1043         kalP2pFuncGetChannelType(eSco, &eChnlType);
1044
1045         cfg80211_ready_on_channel(prGlueInfo->prP2PInfo->prDevHandler, //struct net_device * dev,
1046                         u8SeqNum, //u64 cookie,
1047                         prIEEE80211ChnlStruct, //struct ieee80211_channel * chan,
1048                         eChnlType, //enum nl80211_channel_type channel_type,
1049                         u4Duration, //unsigned int duration,
1050                         GFP_KERNEL); //gfp_t gfp    /* allocation flags */
1051
1052     } while (FALSE);
1053
1054 } /* kalP2PIndicateChannelReady */
1055
1056 VOID
1057 kalP2PIndicateChannelExpired (
1058     IN P_GLUE_INFO_T prGlueInfo,
1059     IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo
1060     )
1061 {
1062
1063     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1064     struct ieee80211_channel *prIEEE80211ChnlStruct = (struct ieee80211_channel *)NULL;
1065     enum nl80211_channel_type eChnlType = NL80211_CHAN_NO_HT;
1066     RF_CHANNEL_INFO_T rRfChannelInfo;
1067
1068     do {
1069         if ((prGlueInfo == NULL) || (prChnlReqInfo == NULL)) {
1070
1071             ASSERT(FALSE);
1072             break;
1073         }
1074
1075         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1076
1077         if (prGlueP2pInfo == NULL) {
1078             ASSERT(FALSE);
1079             break;
1080         }
1081
1082
1083         DBGLOG(P2P, TRACE, ("kalP2PIndicateChannelExpired\n"));
1084
1085         rRfChannelInfo.eBand = prChnlReqInfo->eBand;
1086         rRfChannelInfo.ucChannelNum = prChnlReqInfo->ucReqChnlNum;
1087
1088         prIEEE80211ChnlStruct = kalP2pFuncGetChannelEntry(prGlueP2pInfo, &rRfChannelInfo);
1089
1090
1091         kalP2pFuncGetChannelType(prChnlReqInfo->eChnlSco,
1092                                     &eChnlType);
1093
1094
1095         cfg80211_remain_on_channel_expired(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1096                         prChnlReqInfo->u8Cookie,
1097                         prIEEE80211ChnlStruct,
1098                         eChnlType,
1099                         GFP_KERNEL);
1100
1101     } while (FALSE);
1102
1103 } /* kalP2PIndicateChannelExpired */
1104
1105 VOID
1106 kalP2PIndicateScanDone (
1107     IN P_GLUE_INFO_T prGlueInfo,
1108     IN BOOLEAN fgIsAbort
1109     )
1110 {
1111     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1112
1113     do {
1114         if (prGlueInfo == NULL) {
1115
1116             ASSERT(FALSE);
1117             break;
1118         }
1119
1120         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1121
1122         if (prGlueP2pInfo == NULL) {
1123             ASSERT(FALSE);
1124             break;
1125         }
1126
1127
1128         if (prGlueP2pInfo->prScanRequest) {
1129             cfg80211_scan_done(prGlueP2pInfo->prScanRequest,
1130                         fgIsAbort);
1131
1132             prGlueP2pInfo->prScanRequest = NULL;
1133         }
1134
1135     } while (FALSE);
1136
1137
1138 } /* kalP2PIndicateScanDone */
1139
1140 VOID
1141 kalP2PIndicateBssInfo (
1142     IN P_GLUE_INFO_T prGlueInfo,
1143     IN PUINT_8 pucFrameBuf,
1144     IN UINT_32 u4BufLen,
1145     IN P_RF_CHANNEL_INFO_T prChannelInfo,
1146     IN INT_32 i4SignalStrength
1147     )
1148 {
1149     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1150     struct ieee80211_channel *prChannelEntry = (struct ieee80211_channel *)NULL;
1151     struct ieee80211_mgmt *prBcnProbeRspFrame = (struct ieee80211_mgmt *)pucFrameBuf;
1152     struct cfg80211_bss *prCfg80211Bss = (struct cfg80211_bss *)NULL;
1153
1154     do {
1155         if ((prGlueInfo == NULL) || (pucFrameBuf == NULL) || (prChannelInfo == NULL)) {
1156             ASSERT(FALSE);
1157             break;
1158         }
1159
1160         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1161
1162         if (prGlueP2pInfo == NULL) {
1163             ASSERT(FALSE);
1164             break;
1165         }
1166
1167
1168         prChannelEntry = kalP2pFuncGetChannelEntry(prGlueP2pInfo, prChannelInfo);
1169
1170         if (prChannelEntry == NULL) {
1171             DBGLOG(P2P, TRACE, ("Unknown channel info\n"));
1172             break;
1173         }
1174
1175
1176         //rChannelInfo.center_freq = nicChannelNum2Freq((UINT_32)prChannelInfo->ucChannelNum) / 1000;
1177
1178         prCfg80211Bss = cfg80211_inform_bss_frame(prGlueP2pInfo->wdev.wiphy, //struct wiphy * wiphy,
1179                                 prChannelEntry,
1180                                 prBcnProbeRspFrame,
1181                                 u4BufLen,
1182                                 i4SignalStrength,
1183                                 GFP_KERNEL);
1184
1185
1186         /* Return this structure. */
1187         cfg80211_put_bss(prCfg80211Bss);
1188
1189     } while (FALSE);
1190
1191     return;
1192
1193 } /* kalP2PIndicateBssInfo */
1194
1195 VOID
1196 kalP2PIndicateMgmtTxStatus (
1197     IN P_GLUE_INFO_T prGlueInfo,
1198     IN UINT_64 u8Cookie,
1199     IN BOOLEAN fgIsAck,
1200     IN PUINT_8 pucFrameBuf,
1201     IN UINT_32 u4FrameLen
1202     )
1203 {
1204     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1205
1206     do {
1207         if ((prGlueInfo == NULL) ||
1208                 (pucFrameBuf == NULL) ||
1209                 (u4FrameLen == 0)) {
1210             DBGLOG(P2P, TRACE, ("Unexpected pointer PARAM. 0x%lx, 0x%lx, %ld.", prGlueInfo, pucFrameBuf, u4FrameLen));
1211             ASSERT(FALSE);
1212             break;
1213         }
1214
1215         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1216
1217         cfg80211_mgmt_tx_status(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1218                         u8Cookie,
1219                         pucFrameBuf,
1220                         u4FrameLen,
1221                         fgIsAck,
1222                         GFP_KERNEL);
1223
1224     } while (FALSE);
1225
1226 } /* kalP2PIndicateMgmtTxStatus */
1227
1228 VOID
1229 kalP2PIndicateRxMgmtFrame (
1230     IN P_GLUE_INFO_T prGlueInfo,
1231     IN P_SW_RFB_T prSwRfb
1232     )
1233 {
1234 #define DBG_P2P_MGMT_FRAME_INDICATION 0
1235     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1236     INT_32 i4Freq = 0;
1237     UINT_8 ucChnlNum = 0;
1238 #if DBG_P2P_MGMT_FRAME_INDICATION
1239     P_WLAN_MAC_HEADER_T prWlanHeader = (P_WLAN_MAC_HEADER_T)NULL;
1240 #endif
1241
1242
1243     do {
1244         if ((prGlueInfo == NULL) || (prSwRfb == NULL)) {
1245             ASSERT(FALSE);
1246             break;
1247         }
1248
1249         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1250
1251         ucChnlNum = prSwRfb->prHifRxHdr->ucHwChannelNum;
1252
1253 #if DBG_P2P_MGMT_FRAME_INDICATION
1254
1255         prWlanHeader = (P_WLAN_MAC_HEADER_T)prSwRfb->pvHeader;
1256
1257         switch (prWlanHeader->u2FrameCtrl) {
1258         case MAC_FRAME_PROBE_REQ:
1259             DBGLOG(P2P, TRACE, ("RX Probe Req at channel %d ", ucChnlNum));
1260             break;
1261         case MAC_FRAME_PROBE_RSP:
1262             DBGLOG(P2P, TRACE, ("RX Probe Rsp at channel %d ", ucChnlNum));
1263             break;
1264         case MAC_FRAME_ACTION:
1265             DBGLOG(P2P, TRACE, ("RX Action frame at channel %d ", ucChnlNum));
1266             break;
1267         default:
1268             DBGLOG(P2P, TRACE, ("RX Packet:%d at channel %d ", prWlanHeader->u2FrameCtrl, ucChnlNum));
1269             break;
1270         }
1271
1272         DBGLOG(P2P, TRACE, ("from: "MACSTR"\n", MAC2STR(prWlanHeader->aucAddr2)));
1273 #endif
1274         i4Freq = nicChannelNum2Freq(ucChnlNum) / 1000;
1275
1276 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
1277         cfg80211_rx_mgmt(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1278                             i4Freq,
1279                             RCPI_TO_dBm(prSwRfb->prHifRxHdr->ucRcpi),
1280                             prSwRfb->pvHeader,
1281                             prSwRfb->u2PacketLen,
1282                             GFP_KERNEL);
1283 #else
1284         cfg80211_rx_mgmt(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1285                             i4Freq,
1286                             prSwRfb->pvHeader,
1287                             prSwRfb->u2PacketLen,
1288                             GFP_KERNEL);
1289 #endif
1290
1291     } while (FALSE);
1292
1293 } /* kalP2PIndicateRxMgmtFrame */
1294
1295 VOID
1296 kalP2PGCIndicateConnectionStatus (
1297     IN P_GLUE_INFO_T prGlueInfo,
1298     IN P_P2P_CONNECTION_REQ_INFO_T prP2pConnInfo,
1299     IN PUINT_8 pucRxIEBuf,
1300     IN UINT_16 u2RxIELen,
1301     IN UINT_16 u2StatusReason
1302     )
1303 {
1304     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1305
1306     do {
1307         if (prGlueInfo == NULL) {
1308             ASSERT(FALSE);
1309             break;
1310         }
1311
1312
1313         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1314
1315         if (prP2pConnInfo) {
1316             cfg80211_connect_result(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1317                                     prP2pConnInfo->aucBssid,
1318                                     prP2pConnInfo->aucIEBuf,
1319                                     prP2pConnInfo->u4BufLength,
1320                                     pucRxIEBuf,
1321                                     u2RxIELen,
1322                                     u2StatusReason,
1323                                     GFP_KERNEL);  //gfp_t gfp    /* allocation flags */
1324             prP2pConnInfo->fgIsConnRequest = FALSE;
1325         }
1326         else {
1327             /* Disconnect, what if u2StatusReason == 0? */
1328             cfg80211_disconnected(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1329                                     u2StatusReason,
1330                                     pucRxIEBuf,
1331                                     u2RxIELen,
1332                                     GFP_KERNEL);
1333         }
1334
1335
1336
1337     } while (FALSE);
1338
1339
1340 } /* kalP2PGCIndicateConnectionStatus */
1341
1342
1343 VOID
1344 kalP2PGOStationUpdate (
1345     IN P_GLUE_INFO_T prGlueInfo,
1346     IN P_STA_RECORD_T prCliStaRec,
1347     IN BOOLEAN fgIsNew
1348     )
1349 {
1350     P_GL_P2P_INFO_T prP2pGlueInfo = (P_GL_P2P_INFO_T)NULL;
1351     struct station_info rStationInfo;
1352
1353     do {
1354         if ((prGlueInfo == NULL) || (prCliStaRec == NULL)) {
1355             break;
1356         }
1357
1358
1359         prP2pGlueInfo = prGlueInfo->prP2PInfo;
1360
1361         if (fgIsNew) {
1362             rStationInfo.filled = STATION_INFO_ASSOC_REQ_IES;
1363             rStationInfo.generation = ++prP2pGlueInfo->i4Generation;
1364
1365             rStationInfo.assoc_req_ies = prCliStaRec->pucAssocReqIe;
1366             rStationInfo.assoc_req_ies_len = prCliStaRec->u2AssocReqIeLen;
1367 //          rStationInfo.filled |= STATION_INFO_ASSOC_REQ_IES;
1368
1369             cfg80211_new_sta(prGlueInfo->prP2PInfo->prDevHandler, //struct net_device * dev,
1370                             prCliStaRec->aucMacAddr,
1371                             &rStationInfo,
1372                             GFP_KERNEL);
1373         }
1374         else {
1375             ++prP2pGlueInfo->i4Generation;
1376
1377             cfg80211_del_sta(prGlueInfo->prP2PInfo->prDevHandler, //struct net_device * dev,
1378                             prCliStaRec->aucMacAddr,
1379                             GFP_KERNEL);
1380         }
1381
1382
1383     } while (FALSE);
1384
1385     return;
1386
1387 } /* kalP2PGOStationUpdate */
1388
1389
1390
1391
1392 BOOLEAN
1393 kalP2pFuncGetChannelType(
1394     IN ENUM_CHNL_EXT_T rChnlSco,
1395     OUT enum nl80211_channel_type *channel_type
1396     )
1397 {
1398     BOOLEAN fgIsValid = FALSE;
1399
1400     do {
1401         if (channel_type) {
1402
1403             switch (rChnlSco) {
1404             case CHNL_EXT_SCN:
1405                 *channel_type = NL80211_CHAN_NO_HT;
1406                 break;
1407             case CHNL_EXT_SCA:
1408                 *channel_type = NL80211_CHAN_HT40MINUS;
1409                 break;
1410             case CHNL_EXT_SCB:
1411                 *channel_type = NL80211_CHAN_HT40PLUS;
1412                 break;
1413             default:
1414                 ASSERT(FALSE);
1415                 *channel_type = NL80211_CHAN_NO_HT;
1416                 break;
1417             }
1418
1419         }
1420
1421         fgIsValid = TRUE;
1422     } while (FALSE);
1423
1424     return fgIsValid;
1425 } /* kalP2pFuncGetChannelType */
1426
1427
1428
1429
1430 struct ieee80211_channel *
1431 kalP2pFuncGetChannelEntry (
1432     IN P_GL_P2P_INFO_T prP2pInfo,
1433     IN P_RF_CHANNEL_INFO_T prChannelInfo
1434     )
1435 {
1436     struct ieee80211_channel *prTargetChannelEntry = (struct ieee80211_channel *)NULL;
1437     UINT_32 u4TblSize = 0, u4Idx = 0;
1438
1439     do {
1440         if ((prP2pInfo == NULL) || (prChannelInfo == NULL)) {
1441             break;
1442         }
1443
1444
1445         switch (prChannelInfo->eBand) {
1446         case BAND_2G4:
1447             prTargetChannelEntry = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_2GHZ]->channels;
1448             u4TblSize = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_2GHZ]->n_channels;
1449             break;
1450         case BAND_5G:
1451             prTargetChannelEntry = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_5GHZ]->channels;
1452             u4TblSize = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels;
1453             break;
1454         default:
1455             break;
1456         }
1457
1458
1459         if (prTargetChannelEntry == NULL) {
1460             break;
1461         }
1462
1463
1464
1465         for (u4Idx = 0; u4Idx < u4TblSize; u4Idx++, prTargetChannelEntry++) {
1466             if (prTargetChannelEntry->hw_value == prChannelInfo->ucChannelNum) {
1467                 break;
1468             }
1469
1470         }
1471
1472
1473         if (u4Idx == u4TblSize) {
1474             prTargetChannelEntry = NULL;
1475             break;
1476         }
1477
1478
1479     } while (FALSE);
1480
1481     return prTargetChannelEntry;
1482 } /* kalP2pFuncGetChannelEntry */
1483
1484
1485 /*----------------------------------------------------------------------------*/
1486 /*!
1487 * \brief to set the block list of Hotspot
1488 *
1489 * \param[in]
1490 *           prGlueInfo
1491 *
1492 * \return
1493 */
1494 /*----------------------------------------------------------------------------*/
1495 BOOLEAN
1496 kalP2PSetBlackList (
1497     IN P_GLUE_INFO_T    prGlueInfo,
1498     IN PARAM_MAC_ADDRESS rbssid,
1499     IN BOOLEAN fgIsblock
1500     )
1501 {
1502     UINT_8  aucNullAddr[] = NULL_MAC_ADDR;
1503     BOOLEAN fgIsValid = FALSE;
1504     UINT_32 i;
1505
1506     ASSERT(prGlueInfo);
1507     ASSERT(prGlueInfo->prP2PInfo);
1508
1509     if(fgIsblock) {
1510         for(i = 0; i < 8; i++) {
1511             if(UNEQUAL_MAC_ADDR(rbssid, aucNullAddr)) {
1512                 if(UNEQUAL_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid)) {
1513                     if(EQUAL_MAC_ADDR (&(prGlueInfo->prP2PInfo->aucblackMACList[i]), aucNullAddr)) {
1514                         COPY_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid);
1515                         fgIsValid = FALSE;
1516                         return fgIsValid;
1517                     }
1518                 }
1519             }
1520         }
1521     }
1522     else {
1523         for(i = 0; i < 8; i++) {
1524             if(EQUAL_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid)) {
1525                 COPY_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), aucNullAddr);
1526                 fgIsValid = FALSE;
1527                 return fgIsValid;
1528             }
1529         }
1530     }
1531
1532     return fgIsValid;
1533
1534 }
1535
1536
1537 /*----------------------------------------------------------------------------*/
1538 /*!
1539 * \brief to compare the black list of Hotspot
1540 *
1541 * \param[in]
1542 *           prGlueInfo
1543 *
1544 * \return
1545 */
1546 /*----------------------------------------------------------------------------*/
1547 BOOLEAN
1548 kalP2PCmpBlackList (
1549     IN P_GLUE_INFO_T    prGlueInfo,
1550     IN PARAM_MAC_ADDRESS rbssid
1551     )
1552 {
1553     UINT_8  aucNullAddr[] = NULL_MAC_ADDR;
1554     BOOLEAN fgIsExsit = FALSE;
1555     UINT_32 i;
1556
1557     ASSERT(prGlueInfo);
1558     ASSERT(prGlueInfo->prP2PInfo);
1559
1560     for(i = 0; i < 8; i++) {
1561         if(UNEQUAL_MAC_ADDR(rbssid, aucNullAddr)){
1562             if(EQUAL_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid)) {
1563                 fgIsExsit = TRUE;
1564                 return fgIsExsit;
1565             }
1566         }
1567     }
1568
1569     return fgIsExsit;
1570
1571 }
1572
1573
1574 /*----------------------------------------------------------------------------*/
1575 /*!
1576 * \brief to return the max clients of Hotspot
1577 *
1578 * \param[in]
1579 *           prGlueInfo
1580 *
1581 * \return
1582 */
1583 /*----------------------------------------------------------------------------*/
1584 VOID
1585 kalP2PSetMaxClients (
1586     IN P_GLUE_INFO_T    prGlueInfo,
1587     IN UINT_32 u4MaxClient
1588     )
1589 {
1590     ASSERT(prGlueInfo);
1591     ASSERT(prGlueInfo->prP2PInfo);
1592
1593     if(u4MaxClient == 0 || prGlueInfo->prP2PInfo->ucMaxClients >= P2P_MAXIMUM_CLIENT_COUNT)
1594         prGlueInfo->prP2PInfo->ucMaxClients = P2P_MAXIMUM_CLIENT_COUNT;
1595     else
1596         prGlueInfo->prP2PInfo->ucMaxClients = u4MaxClient;
1597 }
1598
1599
1600 /*----------------------------------------------------------------------------*/
1601 /*!
1602 * \brief to return the max clients of Hotspot
1603 *
1604 * \param[in]
1605 *           prGlueInfo
1606 *
1607 * \return
1608 */
1609 /*----------------------------------------------------------------------------*/
1610 BOOLEAN
1611 kalP2PMaxClients (
1612     IN P_GLUE_INFO_T    prGlueInfo,
1613     IN UINT_32 u4NumClient
1614     )
1615 {
1616     ASSERT(prGlueInfo);
1617     ASSERT(prGlueInfo->prP2PInfo);
1618
1619     if(prGlueInfo->prP2PInfo->ucMaxClients) {
1620         if((UINT_8)u4NumClient > prGlueInfo->prP2PInfo->ucMaxClients)
1621             return TRUE;
1622         else
1623             return FALSE;
1624     }
1625
1626     return FALSE;
1627 }