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