drivers/misc/mediatek/connectivity/conn_soc/drv_wlan/mt_wifi/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 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
1045         cfg80211_ready_on_channel(&prGlueInfo->prP2PInfo->wdev, //struct wireless_dev,
1046                         u8SeqNum, //u64 cookie,
1047                         prIEEE80211ChnlStruct, //struct ieee80211_channel * chan,
1048                         u4Duration, //unsigned int duration,
1049                         GFP_KERNEL); //gfp_t gfp    /* allocation flags */
1050 #else
1051         cfg80211_ready_on_channel(prGlueInfo->prP2PInfo->prDevHandler, //struct net_device * dev,
1052                         u8SeqNum, //u64 cookie,
1053                         prIEEE80211ChnlStruct, //struct ieee80211_channel * chan,
1054                         eChnlType, //enum nl80211_channel_type channel_type,
1055                         u4Duration, //unsigned int duration,
1056                         GFP_KERNEL); //gfp_t gfp    /* allocation flags */
1057 #endif
1058     } while (FALSE);
1059
1060 } /* kalP2PIndicateChannelReady */
1061
1062 VOID
1063 kalP2PIndicateChannelExpired (
1064     IN P_GLUE_INFO_T prGlueInfo,
1065     IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo
1066     )
1067 {
1068
1069     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1070     struct ieee80211_channel *prIEEE80211ChnlStruct = (struct ieee80211_channel *)NULL;
1071     enum nl80211_channel_type eChnlType = NL80211_CHAN_NO_HT;
1072     RF_CHANNEL_INFO_T rRfChannelInfo;
1073
1074     do {
1075         if ((prGlueInfo == NULL) || (prChnlReqInfo == NULL)) {
1076
1077             ASSERT(FALSE);
1078             break;
1079         }
1080
1081         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1082
1083         if (prGlueP2pInfo == NULL) {
1084             ASSERT(FALSE);
1085             break;
1086         }
1087
1088
1089         DBGLOG(P2P, TRACE, ("kalP2PIndicateChannelExpired\n"));
1090
1091         rRfChannelInfo.eBand = prChnlReqInfo->eBand;
1092         rRfChannelInfo.ucChannelNum = prChnlReqInfo->ucReqChnlNum;
1093
1094         prIEEE80211ChnlStruct = kalP2pFuncGetChannelEntry(prGlueP2pInfo, &rRfChannelInfo);
1095
1096
1097         kalP2pFuncGetChannelType(prChnlReqInfo->eChnlSco,
1098                                     &eChnlType);
1099
1100 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
1101         cfg80211_remain_on_channel_expired(&prGlueP2pInfo->wdev, //struct wireless_dev,
1102                         prChnlReqInfo->u8Cookie,
1103                         prIEEE80211ChnlStruct,
1104                         GFP_KERNEL);
1105 #else
1106         cfg80211_remain_on_channel_expired(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1107                         prChnlReqInfo->u8Cookie,
1108                         prIEEE80211ChnlStruct,
1109                         eChnlType,
1110                         GFP_KERNEL);
1111 #endif
1112     } while (FALSE);
1113
1114 } /* kalP2PIndicateChannelExpired */
1115
1116 VOID
1117 kalP2PIndicateScanDone (
1118     IN P_GLUE_INFO_T prGlueInfo,
1119     IN BOOLEAN fgIsAbort
1120     )
1121 {
1122     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1123     struct cfg80211_scan_request *prScanRequest = NULL;
1124         GLUE_SPIN_LOCK_DECLARATION();
1125
1126     do {
1127         if (prGlueInfo == NULL) {
1128
1129             ASSERT(FALSE);
1130             break;
1131         }
1132
1133         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1134
1135         if (prGlueP2pInfo == NULL) {
1136             ASSERT(FALSE);
1137             break;
1138         }
1139
1140                 DBGLOG(INIT, TRACE, ("[p2p] scan complete %p\n", prGlueP2pInfo->prScanRequest));
1141
1142                 GLUE_ACQUIRE_SPIN_LOCK(prGlueInfo, SPIN_LOCK_NET_DEV);
1143                 if(prGlueP2pInfo->prScanRequest != NULL) {
1144                         prScanRequest = prGlueP2pInfo->prScanRequest;
1145             prGlueP2pInfo->prScanRequest = NULL;
1146         }
1147                 GLUE_RELEASE_SPIN_LOCK(prGlueInfo, SPIN_LOCK_NET_DEV);
1148
1149         /* 2. then CFG80211 Indication */
1150
1151         if(prScanRequest != NULL) {
1152
1153                         /* report all queued beacon/probe response frames  to upper layer */
1154                         scanReportBss2Cfg80211(prGlueInfo->prAdapter,BSS_TYPE_P2P_DEVICE,NULL);
1155
1156                         DBGLOG(INIT, TRACE, ("DBG:p2p_cfg_scan_done\n"));
1157             cfg80211_scan_done(prScanRequest, fgIsAbort);
1158         }
1159
1160     } while (FALSE);
1161
1162
1163 } /* kalP2PIndicateScanDone */
1164
1165 VOID
1166 kalP2PIndicateBssInfo (
1167     IN P_GLUE_INFO_T prGlueInfo,
1168     IN PUINT_8 pucFrameBuf,
1169     IN UINT_32 u4BufLen,
1170     IN P_RF_CHANNEL_INFO_T prChannelInfo,
1171     IN INT_32 i4SignalStrength
1172     )
1173 {
1174     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1175     struct ieee80211_channel *prChannelEntry = (struct ieee80211_channel *)NULL;
1176     struct ieee80211_mgmt *prBcnProbeRspFrame = (struct ieee80211_mgmt *)pucFrameBuf;
1177     struct cfg80211_bss *prCfg80211Bss = (struct cfg80211_bss *)NULL;
1178
1179     do {
1180         if ((prGlueInfo == NULL) || (pucFrameBuf == NULL) || (prChannelInfo == NULL)) {
1181             ASSERT(FALSE);
1182             break;
1183         }
1184
1185         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1186
1187         if (prGlueP2pInfo == NULL) {
1188             ASSERT(FALSE);
1189             break;
1190         }
1191
1192
1193         prChannelEntry = kalP2pFuncGetChannelEntry(prGlueP2pInfo, prChannelInfo);
1194
1195         if (prChannelEntry == NULL) {
1196             DBGLOG(P2P, TRACE, ("Unknown channel info\n"));
1197             break;
1198         }
1199
1200
1201         //rChannelInfo.center_freq = nicChannelNum2Freq((UINT_32)prChannelInfo->ucChannelNum) / 1000;
1202
1203         prCfg80211Bss = cfg80211_inform_bss_frame(prGlueP2pInfo->wdev.wiphy, //struct wiphy * wiphy,
1204                                 prChannelEntry,
1205                                 prBcnProbeRspFrame,
1206                                 u4BufLen,
1207                                 i4SignalStrength,
1208                                 GFP_KERNEL);
1209
1210
1211         /* Return this structure. */
1212 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
1213         cfg80211_put_bss(prGlueP2pInfo->wdev.wiphy, prCfg80211Bss);
1214 #else
1215         cfg80211_put_bss(prCfg80211Bss);
1216 #endif
1217         DBGLOG(REQ, INFO, ("indicate ok 0x%p\n", prCfg80211Bss));
1218
1219     } while (FALSE);
1220
1221     return;
1222
1223 } /* kalP2PIndicateBssInfo */
1224
1225 VOID
1226 kalP2PIndicateMgmtTxStatus (
1227     IN P_GLUE_INFO_T prGlueInfo,
1228     IN UINT_64 u8Cookie,
1229     IN BOOLEAN fgIsAck,
1230     IN PUINT_8 pucFrameBuf,
1231     IN UINT_32 u4FrameLen
1232     )
1233 {
1234     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1235
1236     do {
1237         if ((prGlueInfo == NULL) ||
1238                 (pucFrameBuf == NULL) ||
1239                 (u4FrameLen == 0)) {
1240             DBGLOG(P2P, TRACE, ("Unexpected pointer PARAM. %p, %p, %u.",
1241                                 prGlueInfo, pucFrameBuf, u4FrameLen));
1242             ASSERT(FALSE);
1243             break;
1244         }
1245
1246         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1247
1248 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
1249         cfg80211_mgmt_tx_status(&prGlueP2pInfo->wdev, //struct net_device * dev,
1250 #else
1251         cfg80211_mgmt_tx_status(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1252 #endif /* LINUX_VERSION_CODE */
1253                         u8Cookie,
1254                         pucFrameBuf,
1255                         u4FrameLen,
1256                         fgIsAck,
1257                         GFP_KERNEL);
1258
1259     } while (FALSE);
1260
1261 } /* kalP2PIndicateMgmtTxStatus */
1262
1263 VOID
1264 kalP2PIndicateRxMgmtFrame (
1265     IN P_GLUE_INFO_T prGlueInfo,
1266     IN P_SW_RFB_T prSwRfb
1267     )
1268 {
1269 #define DBG_P2P_MGMT_FRAME_INDICATION 0
1270     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1271     INT_32 i4Freq = 0;
1272     UINT_8 ucChnlNum = 0;
1273 #if DBG_P2P_MGMT_FRAME_INDICATION
1274     P_WLAN_MAC_HEADER_T prWlanHeader = (P_WLAN_MAC_HEADER_T)NULL;
1275 #endif
1276
1277
1278     do {
1279         if ((prGlueInfo == NULL) || (prSwRfb == NULL)) {
1280             ASSERT(FALSE);
1281             break;
1282         }
1283
1284         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1285
1286         ucChnlNum = prSwRfb->prHifRxHdr->ucHwChannelNum;
1287
1288 #if DBG_P2P_MGMT_FRAME_INDICATION
1289
1290         prWlanHeader = (P_WLAN_MAC_HEADER_T)prSwRfb->pvHeader;
1291
1292         switch (prWlanHeader->u2FrameCtrl) {
1293         case MAC_FRAME_PROBE_REQ:
1294             DBGLOG(P2P, TRACE, ("RX Probe Req at channel %d ", ucChnlNum));
1295             break;
1296         case MAC_FRAME_PROBE_RSP:
1297             DBGLOG(P2P, TRACE, ("RX Probe Rsp at channel %d ", ucChnlNum));
1298             break;
1299         case MAC_FRAME_ACTION:
1300             DBGLOG(P2P, TRACE, ("RX Action frame at channel %d ", ucChnlNum));
1301             break;
1302         default:
1303             DBGLOG(P2P, TRACE, ("RX Packet:%d at channel %d ", prWlanHeader->u2FrameCtrl, ucChnlNum));
1304             break;
1305         }
1306
1307         DBGLOG(P2P, TRACE, ("from: "MACSTR"\n", MAC2STR(prWlanHeader->aucAddr2)));
1308 #endif
1309         i4Freq = nicChannelNum2Freq(ucChnlNum) / 1000;
1310
1311 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
1312 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
1313         cfg80211_rx_mgmt(&prGlueP2pInfo->wdev, //struct net_device * dev,
1314 #else
1315         cfg80211_rx_mgmt(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1316 #endif /* LINUX_VERSION_CODE */
1317                             i4Freq,
1318                             RCPI_TO_dBm(prSwRfb->prHifRxHdr->ucRcpi),
1319                             prSwRfb->pvHeader,
1320                             prSwRfb->u2PacketLen,
1321                             GFP_ATOMIC);
1322 #else
1323         cfg80211_rx_mgmt(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1324                             i4Freq,
1325                             prSwRfb->pvHeader,
1326                             prSwRfb->u2PacketLen,
1327                             GFP_ATOMIC);
1328 #endif
1329
1330     } while (FALSE);
1331
1332 } /* kalP2PIndicateRxMgmtFrame */
1333
1334 VOID
1335 kalP2PGCIndicateConnectionStatus (
1336     IN P_GLUE_INFO_T prGlueInfo,
1337     IN P_P2P_CONNECTION_REQ_INFO_T prP2pConnInfo,
1338     IN PUINT_8 pucRxIEBuf,
1339     IN UINT_16 u2RxIELen,
1340     IN UINT_16 u2StatusReason
1341     )
1342 {
1343     P_GL_P2P_INFO_T prGlueP2pInfo = (P_GL_P2P_INFO_T)NULL;
1344
1345     do {
1346         if (prGlueInfo == NULL) {
1347             ASSERT(FALSE);
1348             break;
1349         }
1350
1351
1352         prGlueP2pInfo = prGlueInfo->prP2PInfo;
1353
1354         if (prP2pConnInfo) {
1355             cfg80211_connect_result(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1356                                     prP2pConnInfo->aucBssid,
1357                                     prP2pConnInfo->aucIEBuf,
1358                                     prP2pConnInfo->u4BufLength,
1359                                     pucRxIEBuf,
1360                                     u2RxIELen,
1361                                     u2StatusReason,
1362                                     GFP_KERNEL);  //gfp_t gfp    /* allocation flags */
1363             prP2pConnInfo->fgIsConnRequest = FALSE;
1364         }
1365         else {
1366             /* Disconnect, what if u2StatusReason == 0? */
1367             cfg80211_disconnected(prGlueP2pInfo->prDevHandler, //struct net_device * dev,
1368                                     u2StatusReason,
1369                                     pucRxIEBuf,
1370                                     u2RxIELen,
1371                                     GFP_KERNEL);
1372         }
1373
1374
1375
1376     } while (FALSE);
1377
1378
1379 } /* kalP2PGCIndicateConnectionStatus */
1380
1381
1382 VOID
1383 kalP2PGOStationUpdate (
1384     IN P_GLUE_INFO_T prGlueInfo,
1385     IN P_STA_RECORD_T prCliStaRec,
1386     IN BOOLEAN fgIsNew
1387     )
1388 {
1389     P_GL_P2P_INFO_T prP2pGlueInfo = (P_GL_P2P_INFO_T)NULL;
1390     struct station_info rStationInfo;
1391
1392     do {
1393         if ((prGlueInfo == NULL) || (prCliStaRec == NULL)) {
1394             break;
1395         }
1396
1397
1398         prP2pGlueInfo = prGlueInfo->prP2PInfo;
1399
1400         if (fgIsNew) {
1401             rStationInfo.filled = STATION_INFO_ASSOC_REQ_IES;
1402             rStationInfo.generation = ++prP2pGlueInfo->i4Generation;
1403
1404             rStationInfo.assoc_req_ies = prCliStaRec->pucAssocReqIe;
1405             rStationInfo.assoc_req_ies_len = prCliStaRec->u2AssocReqIeLen;
1406 //          rStationInfo.filled |= STATION_INFO_ASSOC_REQ_IES;
1407
1408             cfg80211_new_sta(prGlueInfo->prP2PInfo->prDevHandler, //struct net_device * dev,
1409                             prCliStaRec->aucMacAddr,
1410                             &rStationInfo,
1411                             GFP_KERNEL);
1412         }
1413         else {
1414             ++prP2pGlueInfo->i4Generation;
1415
1416             cfg80211_del_sta(prGlueInfo->prP2PInfo->prDevHandler, //struct net_device * dev,
1417                             prCliStaRec->aucMacAddr,
1418                             GFP_KERNEL);
1419         }
1420
1421
1422     } while (FALSE);
1423
1424     return;
1425
1426 } /* kalP2PGOStationUpdate */
1427
1428
1429
1430
1431 BOOLEAN
1432 kalP2pFuncGetChannelType(
1433     IN ENUM_CHNL_EXT_T rChnlSco,
1434     OUT enum nl80211_channel_type *channel_type
1435     )
1436 {
1437     BOOLEAN fgIsValid = FALSE;
1438
1439     do {
1440         if (channel_type) {
1441
1442             switch (rChnlSco) {
1443             case CHNL_EXT_SCN:
1444                 *channel_type = NL80211_CHAN_NO_HT;
1445                 break;
1446             case CHNL_EXT_SCA:
1447                 *channel_type = NL80211_CHAN_HT40MINUS;
1448                 break;
1449             case CHNL_EXT_SCB:
1450                 *channel_type = NL80211_CHAN_HT40PLUS;
1451                 break;
1452             default:
1453                 ASSERT(FALSE);
1454                 *channel_type = NL80211_CHAN_NO_HT;
1455                 break;
1456             }
1457
1458         }
1459
1460         fgIsValid = TRUE;
1461     } while (FALSE);
1462
1463     return fgIsValid;
1464 } /* kalP2pFuncGetChannelType */
1465
1466
1467
1468
1469 struct ieee80211_channel *
1470 kalP2pFuncGetChannelEntry (
1471     IN P_GL_P2P_INFO_T prP2pInfo,
1472     IN P_RF_CHANNEL_INFO_T prChannelInfo
1473     )
1474 {
1475     struct ieee80211_channel *prTargetChannelEntry = (struct ieee80211_channel *)NULL;
1476     UINT_32 u4TblSize = 0, u4Idx = 0;
1477
1478     do {
1479         if ((prP2pInfo == NULL) || (prChannelInfo == NULL)) {
1480             break;
1481         }
1482
1483
1484         switch (prChannelInfo->eBand) {
1485         case BAND_2G4:
1486             prTargetChannelEntry = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_2GHZ]->channels;
1487             u4TblSize = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_2GHZ]->n_channels;
1488             break;
1489         case BAND_5G:
1490             prTargetChannelEntry = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_5GHZ]->channels;
1491             u4TblSize = prP2pInfo->wdev.wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels;
1492             break;
1493         default:
1494             break;
1495         }
1496
1497
1498         if (prTargetChannelEntry == NULL) {
1499             break;
1500         }
1501
1502
1503
1504         for (u4Idx = 0; u4Idx < u4TblSize; u4Idx++, prTargetChannelEntry++) {
1505             if (prTargetChannelEntry->hw_value == prChannelInfo->ucChannelNum) {
1506                 break;
1507             }
1508
1509         }
1510
1511
1512         if (u4Idx == u4TblSize) {
1513             prTargetChannelEntry = NULL;
1514             break;
1515         }
1516
1517
1518     } while (FALSE);
1519
1520     return prTargetChannelEntry;
1521 } /* kalP2pFuncGetChannelEntry */
1522
1523
1524 /*----------------------------------------------------------------------------*/
1525 /*!
1526 * \brief to set the block list of Hotspot
1527 *
1528 * \param[in]
1529 *           prGlueInfo
1530 *
1531 * \return
1532 */
1533 /*----------------------------------------------------------------------------*/
1534 INT_32
1535 kalP2PSetBlackList (
1536     IN P_GLUE_INFO_T prGlueInfo,
1537     IN PARAM_MAC_ADDRESS rbssid,
1538     IN BOOLEAN fgIsblock
1539     )
1540 {
1541     UINT_8  aucNullAddr[] = NULL_MAC_ADDR;
1542     UINT_32 i;
1543
1544     ASSERT(prGlueInfo);
1545     ASSERT(prGlueInfo->prP2PInfo);
1546
1547     if(EQUAL_MAC_ADDR(rbssid, aucNullAddr))
1548         return -EINVAL;
1549
1550     if(fgIsblock) {
1551         for(i = 0; i < 8; i++) {
1552             if(EQUAL_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid)) {
1553                 break;
1554             }
1555             else if(EQUAL_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), aucNullAddr)) {
1556                 COPY_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid);
1557                 break;
1558             }
1559         }
1560         if (i >= 8) {
1561             DBGLOG(P2P, ERROR, ("AP black list is full, cannot block more STA!!\n"));
1562             return -ENOBUFS;
1563         }
1564     }
1565     else {
1566         for(i = 0; i < 8; i++) {
1567             if(EQUAL_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid)) {
1568                 COPY_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), aucNullAddr);
1569                 break;
1570             }
1571         }
1572         if (i >= 8) {
1573             DBGLOG(P2P, ERROR, ("The STA is not found in black list!!\n"));
1574         }
1575     }
1576
1577     return 0;
1578 }
1579
1580
1581 /*----------------------------------------------------------------------------*/
1582 /*!
1583 * \brief to compare the black list of Hotspot
1584 *
1585 * \param[in]
1586 *           prGlueInfo
1587 *
1588 * \return
1589 */
1590 /*----------------------------------------------------------------------------*/
1591 BOOLEAN
1592 kalP2PCmpBlackList (
1593     IN P_GLUE_INFO_T prGlueInfo,
1594     IN PARAM_MAC_ADDRESS rbssid
1595     )
1596 {
1597     UINT_8  aucNullAddr[] = NULL_MAC_ADDR;
1598     BOOLEAN fgIsExsit = FALSE;
1599     UINT_32 i;
1600
1601     ASSERT(prGlueInfo);
1602     ASSERT(prGlueInfo->prP2PInfo);
1603
1604     for(i = 0; i < 8; i++) {
1605         if(UNEQUAL_MAC_ADDR(rbssid, aucNullAddr)){
1606             if(EQUAL_MAC_ADDR(&(prGlueInfo->prP2PInfo->aucblackMACList[i]), rbssid)) {
1607                 fgIsExsit = TRUE;
1608                 return fgIsExsit;
1609             }
1610         }
1611     }
1612
1613     return fgIsExsit;
1614
1615 }
1616
1617
1618 /*----------------------------------------------------------------------------*/
1619 /*!
1620 * \brief to return the max clients of Hotspot
1621 *
1622 * \param[in]
1623 *           prGlueInfo
1624 *
1625 * \return
1626 */
1627 /*----------------------------------------------------------------------------*/
1628 VOID
1629 kalP2PSetMaxClients (
1630     IN P_GLUE_INFO_T prGlueInfo,
1631     IN UINT_32 u4MaxClient
1632     )
1633 {
1634     ASSERT(prGlueInfo);
1635     ASSERT(prGlueInfo->prP2PInfo);
1636
1637     if(u4MaxClient == 0 || prGlueInfo->prP2PInfo->ucMaxClients >= P2P_MAXIMUM_CLIENT_COUNT)
1638         prGlueInfo->prP2PInfo->ucMaxClients = P2P_MAXIMUM_CLIENT_COUNT;
1639     else
1640         prGlueInfo->prP2PInfo->ucMaxClients = u4MaxClient;
1641 }
1642
1643
1644 /*----------------------------------------------------------------------------*/
1645 /*!
1646 * \brief to return the max clients of Hotspot
1647 *
1648 * \param[in]
1649 *           prGlueInfo
1650 *
1651 * \return
1652 */
1653 /*----------------------------------------------------------------------------*/
1654 BOOLEAN
1655 kalP2PMaxClients (
1656     IN P_GLUE_INFO_T prGlueInfo,
1657     IN UINT_32 u4NumClient
1658     )
1659 {
1660     ASSERT(prGlueInfo);
1661     ASSERT(prGlueInfo->prP2PInfo);
1662
1663     if(prGlueInfo->prP2PInfo->ucMaxClients) {
1664         if((UINT_8)u4NumClient > prGlueInfo->prP2PInfo->ucMaxClients)
1665             return TRUE;
1666         else
1667             return FALSE;
1668     }
1669
1670     return FALSE;
1671 }