git.oblomov.eu Git - linux-2.6/blob - drivers/staging/rt2870/rt_linux.c

   1 /*
   2  *************************************************************************
   3  * Ralink Tech Inc.
   4  * 5F., No.36, Taiyuan St., Jhubei City,
   5  * Hsinchu County 302,
   6  * Taiwan, R.O.C.
   7  *
   8  * (c) Copyright 2002-2007, Ralink Technology, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or modify  *
  11  * it under the terms of the GNU General Public License as published by  *
  12  * the Free Software Foundation; either version 2 of the License, or     *
  13  * (at your option) any later version.                                   *
  14  *                                                                       *
  15  * This program is distributed in the hope that it will be useful,       *
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  18  * GNU General Public License for more details.                          *
  19  *                                                                       *
  20  * You should have received a copy of the GNU General Public License     *
  21  * along with this program; if not, write to the                         *
  22  * Free Software Foundation, Inc.,                                       *
  23  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  24  *                                                                       *
  25  *************************************************************************
  26  */
  27
  28 #include "rt_config.h"
  29
  30 ULONG   RTDebugLevel = RT_DEBUG_ERROR;
  31
  32 BUILD_TIMER_FUNCTION(MlmePeriodicExec);
  33 //BUILD_TIMER_FUNCTION(MlmeRssiReportExec);
  34 BUILD_TIMER_FUNCTION(AsicRxAntEvalTimeout);
  35 BUILD_TIMER_FUNCTION(APSDPeriodicExec);
  36 BUILD_TIMER_FUNCTION(AsicRfTuningExec);
  37 #ifdef RT2870
  38 BUILD_TIMER_FUNCTION(BeaconUpdateExec);
  39 #endif // RT2870 //
  40
  41
  42 #ifdef CONFIG_STA_SUPPORT
  43 BUILD_TIMER_FUNCTION(BeaconTimeout);
  44 BUILD_TIMER_FUNCTION(ScanTimeout);
  45 BUILD_TIMER_FUNCTION(AuthTimeout);
  46 BUILD_TIMER_FUNCTION(AssocTimeout);
  47 BUILD_TIMER_FUNCTION(ReassocTimeout);
  48 BUILD_TIMER_FUNCTION(DisassocTimeout);
  49 BUILD_TIMER_FUNCTION(LinkDownExec);
  50 #ifdef LEAP_SUPPORT
  51 BUILD_TIMER_FUNCTION(LeapAuthTimeout);
  52 #endif
  53 BUILD_TIMER_FUNCTION(StaQuickResponeForRateUpExec);
  54 BUILD_TIMER_FUNCTION(WpaDisassocApAndBlockAssoc);
  55 #endif // CONFIG_STA_SUPPORT //
  56
  57 // for wireless system event message
  58 char const *pWirelessSysEventText[IW_SYS_EVENT_TYPE_NUM] = {
  59         // system status event
  60     "had associated successfully",                                                      /* IW_ASSOC_EVENT_FLAG */
  61     "had disassociated",                                                                        /* IW_DISASSOC_EVENT_FLAG */
  62     "had deauthenticated",                                                                      /* IW_DEAUTH_EVENT_FLAG */
  63     "had been aged-out and disassociated",                                      /* IW_AGEOUT_EVENT_FLAG */
  64     "occurred CounterMeasures attack",                                          /* IW_COUNTER_MEASURES_EVENT_FLAG */
  65     "occurred replay counter different in Key Handshaking",     /* IW_REPLAY_COUNTER_DIFF_EVENT_FLAG */
  66     "occurred RSNIE different in Key Handshaking",                      /* IW_RSNIE_DIFF_EVENT_FLAG */
  67     "occurred MIC different in Key Handshaking",                        /* IW_MIC_DIFF_EVENT_FLAG */
  68     "occurred ICV error in RX",                                                         /* IW_ICV_ERROR_EVENT_FLAG */
  69     "occurred MIC error in RX",                                                         /* IW_MIC_ERROR_EVENT_FLAG */
  70         "Group Key Handshaking timeout",                                                /* IW_GROUP_HS_TIMEOUT_EVENT_FLAG */
  71         "Pairwise Key Handshaking timeout",                                             /* IW_PAIRWISE_HS_TIMEOUT_EVENT_FLAG */
  72         "RSN IE sanity check failure",                                                  /* IW_RSNIE_SANITY_FAIL_EVENT_FLAG */
  73         "set key done in WPA/WPAPSK",                                                   /* IW_SET_KEY_DONE_WPA1_EVENT_FLAG */
  74         "set key done in WPA2/WPA2PSK",                         /* IW_SET_KEY_DONE_WPA2_EVENT_FLAG */
  75         "connects with our wireless client",                    /* IW_STA_LINKUP_EVENT_FLAG */
  76         "disconnects with our wireless client",                 /* IW_STA_LINKDOWN_EVENT_FLAG */
  77         "scan completed"                                                                                /* IW_SCAN_COMPLETED_EVENT_FLAG */
  78         "scan terminate!! Busy!! Enqueue fail!!"                                /* IW_SCAN_ENQUEUE_FAIL_EVENT_FLAG */
  79         };
  80
  81 // for wireless IDS_spoof_attack event message
  82 char const *pWirelessSpoofEventText[IW_SPOOF_EVENT_TYPE_NUM] = {
  83     "detected conflict SSID",                                                           /* IW_CONFLICT_SSID_EVENT_FLAG */
  84     "detected spoofed association response",                            /* IW_SPOOF_ASSOC_RESP_EVENT_FLAG */
  85     "detected spoofed reassociation responses",                         /* IW_SPOOF_REASSOC_RESP_EVENT_FLAG */
  86     "detected spoofed probe response",                                          /* IW_SPOOF_PROBE_RESP_EVENT_FLAG */
  87     "detected spoofed beacon",                                                          /* IW_SPOOF_BEACON_EVENT_FLAG */
  88     "detected spoofed disassociation",                                          /* IW_SPOOF_DISASSOC_EVENT_FLAG */
  89     "detected spoofed authentication",                                          /* IW_SPOOF_AUTH_EVENT_FLAG */
  90     "detected spoofed deauthentication",                                        /* IW_SPOOF_DEAUTH_EVENT_FLAG */
  91     "detected spoofed unknown management frame",                        /* IW_SPOOF_UNKNOWN_MGMT_EVENT_FLAG */
  92         "detected replay attack"                                                                /* IW_REPLAY_ATTACK_EVENT_FLAG */
  93         };
  94
  95 // for wireless IDS_flooding_attack event message
  96 char const *pWirelessFloodEventText[IW_FLOOD_EVENT_TYPE_NUM] = {
  97         "detected authentication flooding",                                             /* IW_FLOOD_AUTH_EVENT_FLAG */
  98     "detected association request flooding",                            /* IW_FLOOD_ASSOC_REQ_EVENT_FLAG */
  99     "detected reassociation request flooding",                          /* IW_FLOOD_REASSOC_REQ_EVENT_FLAG */
 100     "detected probe request flooding",                                          /* IW_FLOOD_PROBE_REQ_EVENT_FLAG */
 101     "detected disassociation flooding",                                         /* IW_FLOOD_DISASSOC_EVENT_FLAG */
 102     "detected deauthentication flooding",                                       /* IW_FLOOD_DEAUTH_EVENT_FLAG */
 103     "detected 802.1x eap-request flooding"                                      /* IW_FLOOD_EAP_REQ_EVENT_FLAG */
 104         };
 105
 106 /* timeout -- ms */
 107 VOID RTMP_SetPeriodicTimer(
 108         IN      NDIS_MINIPORT_TIMER *pTimer,
 109         IN      unsigned long timeout)
 110 {
 111         timeout = ((timeout*HZ) / 1000);
 112         pTimer->expires = jiffies + timeout;
 113         add_timer(pTimer);
 114 }
 115
 116 /* convert NdisMInitializeTimer --> RTMP_OS_Init_Timer */
 117 VOID RTMP_OS_Init_Timer(
 118         IN      PRTMP_ADAPTER pAd,
 119         IN      NDIS_MINIPORT_TIMER *pTimer,
 120         IN      TIMER_FUNCTION function,
 121         IN      PVOID data)
 122 {
 123         init_timer(pTimer);
 124     pTimer->data = (unsigned long)data;
 125     pTimer->function = function;
 126 }
 127
 128
 129 VOID RTMP_OS_Add_Timer(
 130         IN      NDIS_MINIPORT_TIMER             *pTimer,
 131         IN      unsigned long timeout)
 132 {
 133         if (timer_pending(pTimer))
 134                 return;
 135
 136         timeout = ((timeout*HZ) / 1000);
 137         pTimer->expires = jiffies + timeout;
 138         add_timer(pTimer);
 139 }
 140
 141 VOID RTMP_OS_Mod_Timer(
 142         IN      NDIS_MINIPORT_TIMER             *pTimer,
 143         IN      unsigned long timeout)
 144 {
 145         timeout = ((timeout*HZ) / 1000);
 146         mod_timer(pTimer, jiffies + timeout);
 147 }
 148
 149 VOID RTMP_OS_Del_Timer(
 150         IN      NDIS_MINIPORT_TIMER             *pTimer,
 151         OUT     BOOLEAN                                 *pCancelled)
 152 {
 153         if (timer_pending(pTimer))
 154         {
 155                 *pCancelled = del_timer_sync(pTimer);
 156         }
 157         else
 158         {
 159                 *pCancelled = TRUE;
 160         }
 161
 162 }
 163
 164 VOID RTMP_OS_Release_Packet(
 165         IN      PRTMP_ADAPTER pAd,
 166         IN      PQUEUE_ENTRY  pEntry)
 167 {
 168         //RTMPFreeNdisPacket(pAd, (struct sk_buff *)pEntry);
 169 }
 170
 171 // Unify all delay routine by using udelay
 172 VOID RTMPusecDelay(
 173         IN      ULONG   usec)
 174 {
 175         ULONG   i;
 176
 177         for (i = 0; i < (usec / 50); i++)
 178                 udelay(50);
 179
 180         if (usec % 50)
 181                 udelay(usec % 50);
 182 }
 183
 184 void RTMP_GetCurrentSystemTime(LARGE_INTEGER *time)
 185 {
 186         time->u.LowPart = jiffies;
 187 }
 188
 189 // pAd MUST allow to be NULL
 190 NDIS_STATUS os_alloc_mem(
 191         IN      PRTMP_ADAPTER pAd,
 192         OUT     PUCHAR *mem,
 193         IN      ULONG  size)
 194 {
 195         *mem = (PUCHAR) kmalloc(size, GFP_ATOMIC);
 196         if (*mem)
 197                 return (NDIS_STATUS_SUCCESS);
 198         else
 199                 return (NDIS_STATUS_FAILURE);
 200 }
 201
 202 // pAd MUST allow to be NULL
 203 NDIS_STATUS os_free_mem(
 204         IN      PRTMP_ADAPTER pAd,
 205         IN      PUCHAR mem)
 206 {
 207
 208         ASSERT(mem);
 209         kfree(mem);
 210         return (NDIS_STATUS_SUCCESS);
 211 }
 212
 213
 214 PNDIS_PACKET RTMP_AllocateFragPacketBuffer(
 215         IN      PRTMP_ADAPTER pAd,
 216         IN      ULONG   Length)
 217 {
 218         struct sk_buff *pkt;
 219
 220         pkt = dev_alloc_skb(Length);
 221
 222         if (pkt == NULL)
 223         {
 224                 DBGPRINT(RT_DEBUG_ERROR, ("can't allocate frag rx %ld size packet\n",Length));
 225         }
 226
 227         if (pkt)
 228         {
 229                 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
 230         }
 231
 232         return (PNDIS_PACKET) pkt;
 233 }
 234
 235
 236 PNDIS_PACKET RTMP_AllocateTxPacketBuffer(
 237         IN      PRTMP_ADAPTER pAd,
 238         IN      ULONG   Length,
 239         IN      BOOLEAN Cached,
 240         OUT     PVOID   *VirtualAddress)
 241 {
 242         struct sk_buff *pkt;
 243
 244         pkt = dev_alloc_skb(Length);
 245
 246         if (pkt == NULL)
 247         {
 248                 DBGPRINT(RT_DEBUG_ERROR, ("can't allocate tx %ld size packet\n",Length));
 249         }
 250
 251         if (pkt)
 252         {
 253                 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
 254                 *VirtualAddress = (PVOID) pkt->data;
 255         }
 256         else
 257         {
 258                 *VirtualAddress = (PVOID) NULL;
 259         }
 260
 261         return (PNDIS_PACKET) pkt;
 262 }
 263
 264
 265 VOID build_tx_packet(
 266         IN      PRTMP_ADAPTER   pAd,
 267         IN      PNDIS_PACKET    pPacket,
 268         IN      PUCHAR  pFrame,
 269         IN      ULONG   FrameLen)
 270 {
 271
 272         struct sk_buff  *pTxPkt;
 273
 274         ASSERT(pPacket);
 275         pTxPkt = RTPKT_TO_OSPKT(pPacket);
 276
 277         NdisMoveMemory(skb_put(pTxPkt, FrameLen), pFrame, FrameLen);
 278 }
 279
 280 VOID    RTMPFreeAdapter(
 281         IN      PRTMP_ADAPTER   pAd)
 282 {
 283     POS_COOKIE os_cookie;
 284         int index;
 285
 286         os_cookie=(POS_COOKIE)pAd->OS_Cookie;
 287
 288         kfree(pAd->BeaconBuf);
 289
 290
 291         NdisFreeSpinLock(&pAd->MgmtRingLock);
 292
 293
 294         for (index =0 ; index < NUM_OF_TX_RING; index++)
 295         {
 296         NdisFreeSpinLock(&pAd->TxSwQueueLock[index]);
 297                 NdisFreeSpinLock(&pAd->DeQueueLock[index]);
 298                 pAd->DeQueueRunning[index] = FALSE;
 299         }
 300
 301         NdisFreeSpinLock(&pAd->irq_lock);
 302
 303
 304         vfree(pAd); // pci_free_consistent(os_cookie->pci_dev,sizeof(RTMP_ADAPTER),pAd,os_cookie->pAd_pa);
 305         kfree(os_cookie);
 306 }
 307
 308 BOOLEAN OS_Need_Clone_Packet(void)
 309 {
 310         return (FALSE);
 311 }
 312
 313
 314
 315 /*
 316         ========================================================================
 317
 318         Routine Description:
 319                 clone an input NDIS PACKET to another one. The new internally created NDIS PACKET
 320                 must have only one NDIS BUFFER
 321                 return - byte copied. 0 means can't create NDIS PACKET
 322                 NOTE: internally created NDIS_PACKET should be destroyed by RTMPFreeNdisPacket
 323
 324         Arguments:
 325                 pAd     Pointer to our adapter
 326                 pInsAMSDUHdr    EWC A-MSDU format has extra 14-bytes header. if TRUE, insert this 14-byte hdr in front of MSDU.
 327                 *pSrcTotalLen                   return total packet length. This lenght is calculated with 802.3 format packet.
 328
 329         Return Value:
 330                 NDIS_STATUS_SUCCESS
 331                 NDIS_STATUS_FAILURE
 332
 333         Note:
 334
 335         ========================================================================
 336 */
 337 NDIS_STATUS RTMPCloneNdisPacket(
 338         IN      PRTMP_ADAPTER   pAd,
 339         IN      BOOLEAN                 pInsAMSDUHdr,
 340         IN      PNDIS_PACKET    pInPacket,
 341         OUT PNDIS_PACKET   *ppOutPacket)
 342 {
 343
 344         struct sk_buff *pkt;
 345
 346         ASSERT(pInPacket);
 347         ASSERT(ppOutPacket);
 348
 349         // 1. Allocate a packet
 350         pkt = dev_alloc_skb(2048);
 351
 352         if (pkt == NULL)
 353         {
 354                 return NDIS_STATUS_FAILURE;
 355         }
 356
 357         skb_put(pkt, GET_OS_PKT_LEN(pInPacket));
 358         NdisMoveMemory(pkt->data, GET_OS_PKT_DATAPTR(pInPacket), GET_OS_PKT_LEN(pInPacket));
 359         *ppOutPacket = OSPKT_TO_RTPKT(pkt);
 360
 361
 362         RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
 363
 364         printk("###Clone###\n");
 365
 366         return NDIS_STATUS_SUCCESS;
 367 }
 368
 369
 370 // the allocated NDIS PACKET must be freed via RTMPFreeNdisPacket()
 371 NDIS_STATUS RTMPAllocateNdisPacket(
 372         IN      PRTMP_ADAPTER   pAd,
 373         OUT PNDIS_PACKET   *ppPacket,
 374         IN      PUCHAR                  pHeader,
 375         IN      UINT                    HeaderLen,
 376         IN      PUCHAR                  pData,
 377         IN      UINT                    DataLen)
 378 {
 379         PNDIS_PACKET    pPacket;
 380         ASSERT(pData);
 381         ASSERT(DataLen);
 382
 383         // 1. Allocate a packet
 384         pPacket = (PNDIS_PACKET *) dev_alloc_skb(HeaderLen + DataLen + TXPADDING_SIZE);
 385         if (pPacket == NULL)
 386         {
 387                 *ppPacket = NULL;
 388 #ifdef DEBUG
 389                 printk("RTMPAllocateNdisPacket Fail\n\n");
 390 #endif
 391                 return NDIS_STATUS_FAILURE;
 392         }
 393
 394         // 2. clone the frame content
 395         if (HeaderLen > 0)
 396                 NdisMoveMemory(GET_OS_PKT_DATAPTR(pPacket), pHeader, HeaderLen);
 397         if (DataLen > 0)
 398                 NdisMoveMemory(GET_OS_PKT_DATAPTR(pPacket) + HeaderLen, pData, DataLen);
 399
 400         // 3. update length of packet
 401         skb_put(GET_OS_PKT_TYPE(pPacket), HeaderLen+DataLen);
 402
 403         RTMP_SET_PACKET_SOURCE(pPacket, PKTSRC_NDIS);
 404 //      printk("%s : pPacket = %p, len = %d\n", __func__, pPacket, GET_OS_PKT_LEN(pPacket));
 405         *ppPacket = pPacket;
 406         return NDIS_STATUS_SUCCESS;
 407 }
 408
 409 /*
 410   ========================================================================
 411   Description:
 412         This routine frees a miniport internally allocated NDIS_PACKET and its
 413         corresponding NDIS_BUFFER and allocated memory.
 414   ========================================================================
 415 */
 416 VOID RTMPFreeNdisPacket(
 417         IN PRTMP_ADAPTER pAd,
 418         IN PNDIS_PACKET  pPacket)
 419 {
 420         dev_kfree_skb_any(RTPKT_TO_OSPKT(pPacket));
 421 }
 422
 423
 424 // IRQL = DISPATCH_LEVEL
 425 // NOTE: we do have an assumption here, that Byte0 and Byte1 always reasid at the same
 426 //                       scatter gather buffer
 427 NDIS_STATUS Sniff2BytesFromNdisBuffer(
 428         IN      PNDIS_BUFFER    pFirstBuffer,
 429         IN      UCHAR                   DesiredOffset,
 430         OUT PUCHAR                      pByte0,
 431         OUT PUCHAR                      pByte1)
 432 {
 433     *pByte0 = *(PUCHAR)(pFirstBuffer + DesiredOffset);
 434     *pByte1 = *(PUCHAR)(pFirstBuffer + DesiredOffset + 1);
 435
 436         return NDIS_STATUS_SUCCESS;
 437 }
 438
 439
 440 void RTMP_QueryPacketInfo(
 441         IN  PNDIS_PACKET pPacket,
 442         OUT PACKET_INFO  *pPacketInfo,
 443         OUT PUCHAR               *pSrcBufVA,
 444         OUT     UINT             *pSrcBufLen)
 445 {
 446         pPacketInfo->BufferCount = 1;
 447         pPacketInfo->pFirstBuffer = GET_OS_PKT_DATAPTR(pPacket);
 448         pPacketInfo->PhysicalBufferCount = 1;
 449         pPacketInfo->TotalPacketLength = GET_OS_PKT_LEN(pPacket);
 450
 451         *pSrcBufVA = GET_OS_PKT_DATAPTR(pPacket);
 452         *pSrcBufLen = GET_OS_PKT_LEN(pPacket);
 453 }
 454
 455 void RTMP_QueryNextPacketInfo(
 456         IN  PNDIS_PACKET *ppPacket,
 457         OUT PACKET_INFO  *pPacketInfo,
 458         OUT PUCHAR               *pSrcBufVA,
 459         OUT     UINT             *pSrcBufLen)
 460 {
 461         PNDIS_PACKET pPacket = NULL;
 462
 463         if (*ppPacket)
 464                 pPacket = GET_OS_PKT_NEXT(*ppPacket);
 465
 466         if (pPacket)
 467         {
 468                 pPacketInfo->BufferCount = 1;
 469                 pPacketInfo->pFirstBuffer = GET_OS_PKT_DATAPTR(pPacket);
 470                 pPacketInfo->PhysicalBufferCount = 1;
 471                 pPacketInfo->TotalPacketLength = GET_OS_PKT_LEN(pPacket);
 472
 473                 *pSrcBufVA = GET_OS_PKT_DATAPTR(pPacket);
 474                 *pSrcBufLen = GET_OS_PKT_LEN(pPacket);
 475                 *ppPacket = GET_OS_PKT_NEXT(pPacket);
 476         }
 477         else
 478         {
 479                 pPacketInfo->BufferCount = 0;
 480                 pPacketInfo->pFirstBuffer = NULL;
 481                 pPacketInfo->PhysicalBufferCount = 0;
 482                 pPacketInfo->TotalPacketLength = 0;
 483
 484                 *pSrcBufVA = NULL;
 485                 *pSrcBufLen = 0;
 486                 *ppPacket = NULL;
 487         }
 488 }
 489
 490 // not yet support MBSS
 491 PNET_DEV get_netdev_from_bssid(
 492         IN      PRTMP_ADAPTER   pAd,
 493         IN      UCHAR                   FromWhichBSSID)
 494 {
 495     PNET_DEV dev_p = NULL;
 496
 497
 498 #ifdef CONFIG_STA_SUPPORT
 499         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 500         {
 501                 dev_p = pAd->net_dev;
 502         }
 503 #endif // CONFIG_STA_SUPPORT //
 504
 505         ASSERT(dev_p);
 506         return dev_p; /* return one of MBSS */
 507 }
 508
 509 PNDIS_PACKET DuplicatePacket(
 510         IN      PRTMP_ADAPTER   pAd,
 511         IN      PNDIS_PACKET    pPacket,
 512         IN      UCHAR                   FromWhichBSSID)
 513 {
 514         struct sk_buff  *skb;
 515         PNDIS_PACKET    pRetPacket = NULL;
 516         USHORT                  DataSize;
 517         UCHAR                   *pData;
 518
 519         DataSize = (USHORT) GET_OS_PKT_LEN(pPacket);
 520         pData = (PUCHAR) GET_OS_PKT_DATAPTR(pPacket);
 521
 522
 523         skb = skb_clone(RTPKT_TO_OSPKT(pPacket), MEM_ALLOC_FLAG);
 524         if (skb)
 525         {
 526                 skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
 527                 pRetPacket = OSPKT_TO_RTPKT(skb);
 528         }
 529
 530 #if 0
 531         if ((skb = __dev_alloc_skb(DataSize + 2+32, MEM_ALLOC_FLAG)) != NULL)
 532         {
 533                 skb_reserve(skb, 2+32);
 534                 NdisMoveMemory(skb->tail, pData, DataSize);
 535                 skb_put(skb, DataSize);
 536                 skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
 537                 pRetPacket = OSPKT_TO_RTPKT(skb);
 538         }
 539 #endif
 540
 541         return pRetPacket;
 542
 543 }
 544
 545 PNDIS_PACKET duplicate_pkt(
 546         IN      PRTMP_ADAPTER   pAd,
 547         IN      PUCHAR                  pHeader802_3,
 548     IN  UINT            HdrLen,
 549         IN      PUCHAR                  pData,
 550         IN      ULONG                   DataSize,
 551         IN      UCHAR                   FromWhichBSSID)
 552 {
 553         struct sk_buff  *skb;
 554         PNDIS_PACKET    pPacket = NULL;
 555
 556
 557         if ((skb = __dev_alloc_skb(HdrLen + DataSize + 2, MEM_ALLOC_FLAG)) != NULL)
 558         {
 559                 skb_reserve(skb, 2);
 560                 NdisMoveMemory(skb->tail, pHeader802_3, HdrLen);
 561                 skb_put(skb, HdrLen);
 562                 NdisMoveMemory(skb->tail, pData, DataSize);
 563                 skb_put(skb, DataSize);
 564                 skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
 565                 pPacket = OSPKT_TO_RTPKT(skb);
 566         }
 567
 568         return pPacket;
 569 }
 570
 571
 572 #define TKIP_TX_MIC_SIZE                8
 573 PNDIS_PACKET duplicate_pkt_with_TKIP_MIC(
 574         IN      PRTMP_ADAPTER   pAd,
 575         IN      PNDIS_PACKET    pPacket)
 576 {
 577         struct sk_buff  *skb, *newskb;
 578
 579
 580         skb = RTPKT_TO_OSPKT(pPacket);
 581         if (skb_tailroom(skb) < TKIP_TX_MIC_SIZE)
 582         {
 583                 // alloc a new skb and copy the packet
 584                 newskb = skb_copy_expand(skb, skb_headroom(skb), TKIP_TX_MIC_SIZE, GFP_ATOMIC);
 585                 dev_kfree_skb_any(skb);
 586                 if (newskb == NULL)
 587                 {
 588                         DBGPRINT(RT_DEBUG_ERROR, ("Extend Tx.MIC for packet failed!, dropping packet!\n"));
 589                         return NULL;
 590                 }
 591                 skb = newskb;
 592         }
 593
 594         return OSPKT_TO_RTPKT(skb);
 595
 596 #if 0
 597         if ((data = skb_put(skb, TKIP_TX_MIC_SIZE)) != NULL)
 598         {       // If we can extend it, well, copy it first.
 599                 NdisMoveMemory(data, pAd->PrivateInfo.Tx.MIC, TKIP_TX_MIC_SIZE);
 600         }
 601         else
 602         {
 603                 // Otherwise, copy the packet.
 604                 newskb = skb_copy_expand(skb, skb_headroom(skb), TKIP_TX_MIC_SIZE, GFP_ATOMIC);
 605                 dev_kfree_skb_any(skb);
 606                 if (newskb == NULL)
 607                 {
 608                         DBGPRINT(RT_DEBUG_ERROR, ("Extend Tx.MIC to packet failed!, dropping packet\n"));
 609                         return NULL;
 610                 }
 611                 skb = newskb;
 612
 613                 NdisMoveMemory(skb->tail, pAd->PrivateInfo.Tx.MIC, TKIP_TX_MIC_SIZE);
 614                 skb_put(skb, TKIP_TX_MIC_SIZE);
 615         }
 616
 617         return OSPKT_TO_RTPKT(skb);
 618 #endif
 619
 620 }
 621
 622
 623
 624
 625 PNDIS_PACKET ClonePacket(
 626         IN      PRTMP_ADAPTER   pAd,
 627         IN      PNDIS_PACKET    pPacket,
 628         IN      PUCHAR                  pData,
 629         IN      ULONG                   DataSize)
 630 {
 631         struct sk_buff  *pRxPkt;
 632         struct sk_buff  *pClonedPkt;
 633
 634         ASSERT(pPacket);
 635         pRxPkt = RTPKT_TO_OSPKT(pPacket);
 636
 637         // clone the packet
 638         pClonedPkt = skb_clone(pRxPkt, MEM_ALLOC_FLAG);
 639
 640         if (pClonedPkt)
 641         {
 642         // set the correct dataptr and data len
 643         pClonedPkt->dev = pRxPkt->dev;
 644         pClonedPkt->data = pData;
 645         pClonedPkt->len = DataSize;
 646         pClonedPkt->tail = pClonedPkt->data + pClonedPkt->len;
 647                 ASSERT(DataSize < 1530);
 648         }
 649         return pClonedPkt;
 650 }
 651
 652 //
 653 // change OS packet DataPtr and DataLen
 654 //
 655 void  update_os_packet_info(
 656         IN      PRTMP_ADAPTER   pAd,
 657         IN      RX_BLK                  *pRxBlk,
 658         IN  UCHAR                       FromWhichBSSID)
 659 {
 660         struct sk_buff  *pOSPkt;
 661
 662         ASSERT(pRxBlk->pRxPacket);
 663         pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
 664
 665         pOSPkt->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
 666         pOSPkt->data = pRxBlk->pData;
 667         pOSPkt->len = pRxBlk->DataSize;
 668         pOSPkt->tail = pOSPkt->data + pOSPkt->len;
 669 }
 670
 671
 672 void wlan_802_11_to_802_3_packet(
 673         IN      PRTMP_ADAPTER   pAd,
 674         IN      RX_BLK                  *pRxBlk,
 675         IN      PUCHAR                  pHeader802_3,
 676         IN  UCHAR                       FromWhichBSSID)
 677 {
 678         struct sk_buff  *pOSPkt;
 679
 680         ASSERT(pRxBlk->pRxPacket);
 681         ASSERT(pHeader802_3);
 682
 683         pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
 684
 685         pOSPkt->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
 686         pOSPkt->data = pRxBlk->pData;
 687         pOSPkt->len = pRxBlk->DataSize;
 688         pOSPkt->tail = pOSPkt->data + pOSPkt->len;
 689
 690         //
 691         // copy 802.3 header
 692         //
 693         //
 694
 695 #ifdef CONFIG_STA_SUPPORT
 696         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 697                 NdisMoveMemory(skb_push(pOSPkt, LENGTH_802_3), pHeader802_3, LENGTH_802_3);
 698 #endif // CONFIG_STA_SUPPORT //
 699         }
 700
 701
 702
 703 void announce_802_3_packet(
 704         IN      PRTMP_ADAPTER   pAd,
 705         IN      PNDIS_PACKET    pPacket)
 706 {
 707
 708         struct sk_buff  *pRxPkt;
 709
 710         ASSERT(pPacket);
 711
 712         pRxPkt = RTPKT_TO_OSPKT(pPacket);
 713
 714 #ifdef CONFIG_STA_SUPPORT
 715 #endif // CONFIG_STA_SUPPORT //
 716
 717     /* Push up the protocol stack */
 718 #ifdef IKANOS_VX_1X0
 719         IKANOS_DataFrameRx(pAd, pRxPkt->dev, pRxPkt, pRxPkt->len);
 720 #else
 721         pRxPkt->protocol = eth_type_trans(pRxPkt, pRxPkt->dev);
 722
 723 //#ifdef CONFIG_5VT_ENHANCE
 724 //      *(int*)(pRxPkt->cb) = BRIDGE_TAG;
 725 //#endif
 726         netif_rx(pRxPkt);
 727 #endif // IKANOS_VX_1X0 //
 728 }
 729
 730
 731 PRTMP_SCATTER_GATHER_LIST
 732 rt_get_sg_list_from_packet(PNDIS_PACKET pPacket, RTMP_SCATTER_GATHER_LIST *sg)
 733 {
 734         sg->NumberOfElements = 1;
 735         sg->Elements[0].Address =  GET_OS_PKT_DATAPTR(pPacket);
 736         sg->Elements[0].Length = GET_OS_PKT_LEN(pPacket);
 737         return (sg);
 738 }
 739
 740 void hex_dump(char *str, unsigned char *pSrcBufVA, unsigned int SrcBufLen)
 741 {
 742         unsigned char *pt;
 743         int x;
 744
 745         if (RTDebugLevel < RT_DEBUG_TRACE)
 746                 return;
 747
 748         pt = pSrcBufVA;
 749         printk("%s: %p, len = %d\n",str,  pSrcBufVA, SrcBufLen);
 750         for (x=0; x<SrcBufLen; x++)
 751         {
 752                 if (x % 16 == 0)
 753                         printk("0x%04x : ", x);
 754                 printk("%02x ", ((unsigned char)pt[x]));
 755                 if (x%16 == 15) printk("\n");
 756         }
 757         printk("\n");
 758 }
 759
 760 /*
 761         ========================================================================
 762
 763         Routine Description:
 764                 Send log message through wireless event
 765
 766                 Support standard iw_event with IWEVCUSTOM. It is used below.
 767
 768                 iwreq_data.data.flags is used to store event_flag that is defined by user.
 769                 iwreq_data.data.length is the length of the event log.
 770
 771                 The format of the event log is composed of the entry's MAC address and
 772                 the desired log message (refer to pWirelessEventText).
 773
 774                         ex: 11:22:33:44:55:66 has associated successfully
 775
 776                 p.s. The requirement of Wireless Extension is v15 or newer.
 777
 778         ========================================================================
 779 */
 780 VOID RTMPSendWirelessEvent(
 781         IN      PRTMP_ADAPTER   pAd,
 782         IN      USHORT                  Event_flag,
 783         IN      PUCHAR                  pAddr,
 784         IN      UCHAR                   BssIdx,
 785         IN      CHAR                    Rssi)
 786 {
 787 #if WIRELESS_EXT >= 15
 788
 789         union   iwreq_data      wrqu;
 790         PUCHAR  pBuf = NULL, pBufPtr = NULL;
 791         USHORT  event, type, BufLen;
 792         UCHAR   event_table_len = 0;
 793
 794         type = Event_flag & 0xFF00;
 795         event = Event_flag & 0x00FF;
 796
 797         switch (type)
 798         {
 799                 case IW_SYS_EVENT_FLAG_START:
 800                         event_table_len = IW_SYS_EVENT_TYPE_NUM;
 801                         break;
 802
 803                 case IW_SPOOF_EVENT_FLAG_START:
 804                         event_table_len = IW_SPOOF_EVENT_TYPE_NUM;
 805                         break;
 806
 807                 case IW_FLOOD_EVENT_FLAG_START:
 808                         event_table_len = IW_FLOOD_EVENT_TYPE_NUM;
 809                         break;
 810         }
 811
 812         if (event_table_len == 0)
 813         {
 814                 DBGPRINT(RT_DEBUG_ERROR, ("%s : The type(%0x02x) is not valid.\n", __func__, type));
 815                 return;
 816         }
 817
 818         if (event >= event_table_len)
 819         {
 820                 DBGPRINT(RT_DEBUG_ERROR, ("%s : The event(%0x02x) is not valid.\n", __func__, event));
 821                 return;
 822         }
 823
 824         //Allocate memory and copy the msg.
 825         if((pBuf = kmalloc(IW_CUSTOM_MAX_LEN, GFP_ATOMIC)) != NULL)
 826         {
 827                 //Prepare the payload
 828                 memset(pBuf, 0, IW_CUSTOM_MAX_LEN);
 829
 830                 pBufPtr = pBuf;
 831
 832                 if (pAddr)
 833                         pBufPtr += sprintf(pBufPtr, "(RT2860) STA(%02x:%02x:%02x:%02x:%02x:%02x) ", PRINT_MAC(pAddr));
 834                 else if (BssIdx < MAX_MBSSID_NUM)
 835                         pBufPtr += sprintf(pBufPtr, "(RT2860) BSS(ra%d) ", BssIdx);
 836                 else
 837                         pBufPtr += sprintf(pBufPtr, "(RT2860) ");
 838
 839                 if (type == IW_SYS_EVENT_FLAG_START)
 840                         pBufPtr += sprintf(pBufPtr, "%s", pWirelessSysEventText[event]);
 841                 else if (type == IW_SPOOF_EVENT_FLAG_START)
 842                         pBufPtr += sprintf(pBufPtr, "%s (RSSI=%d)", pWirelessSpoofEventText[event], Rssi);
 843                 else if (type == IW_FLOOD_EVENT_FLAG_START)
 844                         pBufPtr += sprintf(pBufPtr, "%s", pWirelessFloodEventText[event]);
 845                 else
 846                         pBufPtr += sprintf(pBufPtr, "%s", "unknown event");
 847
 848                 pBufPtr[pBufPtr - pBuf] = '\0';
 849                 BufLen = pBufPtr - pBuf;
 850
 851                 memset(&wrqu, 0, sizeof(wrqu));
 852             wrqu.data.flags = Event_flag;
 853                 wrqu.data.length = BufLen;
 854
 855                 //send wireless event
 856             wireless_send_event(pAd->net_dev, IWEVCUSTOM, &wrqu, pBuf);
 857
 858                 //DBGPRINT(RT_DEBUG_TRACE, ("%s : %s\n", __func__, pBuf));
 859
 860                 kfree(pBuf);
 861         }
 862         else
 863                 DBGPRINT(RT_DEBUG_ERROR, ("%s : Can't allocate memory for wireless event.\n", __func__));
 864 #else
 865         DBGPRINT(RT_DEBUG_ERROR, ("%s : The Wireless Extension MUST be v15 or newer.\n", __func__));
 866 #endif  /* WIRELESS_EXT >= 15 */
 867 }
 868
 869
 870 #ifdef CONFIG_STA_SUPPORT
 871 void send_monitor_packets(
 872         IN      PRTMP_ADAPTER   pAd,
 873         IN      RX_BLK                  *pRxBlk)
 874 {
 875     struct sk_buff      *pOSPkt;
 876     wlan_ng_prism2_header *ph;
 877     int rate_index = 0;
 878     USHORT header_len = 0;
 879     UCHAR temp_header[40] = {0};
 880
 881     u_int32_t ralinkrate[256] = {2,4,11,22, 12,18,24,36,48,72,96,  108,   109, 110, 111, 112, 13, 26, 39, 52,78,104, 117, 130, 26, 52, 78,104, 156, 208, 234, 260, 27, 54,81,108,162, 216, 243, 270, // Last 38
 882         54, 108, 162, 216, 324, 432, 486, 540,  14, 29, 43, 57, 87, 115, 130, 144, 29, 59,87,115, 173, 230,260, 288, 30, 60,90,120,180,240,270,300,60,120,180,240,360,480,540,600, 0,1,2,3,4,5,6,7,8,9,10,
 883         11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80};
 884
 885
 886     ASSERT(pRxBlk->pRxPacket);
 887     if (pRxBlk->DataSize < 10)
 888     {
 889         DBGPRINT(RT_DEBUG_ERROR, ("%s : Size is too small! (%d)\n", __func__, pRxBlk->DataSize));
 890                 goto err_free_sk_buff;
 891     }
 892
 893     if (pRxBlk->DataSize + sizeof(wlan_ng_prism2_header) > RX_BUFFER_AGGRESIZE)
 894     {
 895         DBGPRINT(RT_DEBUG_ERROR, ("%s : Size is too large! (%zu)\n", __func__, pRxBlk->DataSize + sizeof(wlan_ng_prism2_header)));
 896                 goto err_free_sk_buff;
 897     }
 898
 899     pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
 900         pOSPkt->dev = get_netdev_from_bssid(pAd, BSS0);
 901     if (pRxBlk->pHeader->FC.Type == BTYPE_DATA)
 902     {
 903         pRxBlk->DataSize -= LENGTH_802_11;
 904         if ((pRxBlk->pHeader->FC.ToDs == 1) &&
 905             (pRxBlk->pHeader->FC.FrDs == 1))
 906             header_len = LENGTH_802_11_WITH_ADDR4;
 907         else
 908             header_len = LENGTH_802_11;
 909
 910         // QOS
 911         if (pRxBlk->pHeader->FC.SubType & 0x08)
 912         {
 913             header_len += 2;
 914                 // Data skip QOS contorl field
 915                 pRxBlk->DataSize -=2;
 916         }
 917
 918         // Order bit: A-Ralink or HTC+
 919         if (pRxBlk->pHeader->FC.Order)
 920         {
 921             header_len += 4;
 922                         // Data skip HTC contorl field
 923                         pRxBlk->DataSize -= 4;
 924         }
 925
 926         // Copy Header
 927         if (header_len <= 40)
 928             NdisMoveMemory(temp_header, pRxBlk->pData, header_len);
 929
 930         // skip HW padding
 931         if (pRxBlk->RxD.L2PAD)
 932             pRxBlk->pData += (header_len + 2);
 933         else
 934             pRxBlk->pData += header_len;
 935     } //end if
 936
 937
 938         if (pRxBlk->DataSize < pOSPkt->len) {
 939         skb_trim(pOSPkt,pRxBlk->DataSize);
 940     } else {
 941         skb_put(pOSPkt,(pRxBlk->DataSize - pOSPkt->len));
 942     } //end if
 943
 944     if ((pRxBlk->pData - pOSPkt->data) > 0) {
 945             skb_put(pOSPkt,(pRxBlk->pData - pOSPkt->data));
 946             skb_pull(pOSPkt,(pRxBlk->pData - pOSPkt->data));
 947     } //end if
 948
 949     if (skb_headroom(pOSPkt) < (sizeof(wlan_ng_prism2_header)+ header_len)) {
 950         if (pskb_expand_head(pOSPkt, (sizeof(wlan_ng_prism2_header) + header_len), 0, GFP_ATOMIC)) {
 951                 DBGPRINT(RT_DEBUG_ERROR, ("%s : Reallocate header size of sk_buff fail!\n", __func__));
 952                         goto err_free_sk_buff;
 953             } //end if
 954     } //end if
 955
 956     if (header_len > 0)
 957         NdisMoveMemory(skb_push(pOSPkt, header_len), temp_header, header_len);
 958
 959     ph = (wlan_ng_prism2_header *) skb_push(pOSPkt, sizeof(wlan_ng_prism2_header));
 960         NdisZeroMemory(ph, sizeof(wlan_ng_prism2_header));
 961
 962     ph->msgcode             = DIDmsg_lnxind_wlansniffrm;
 963         ph->msglen                  = sizeof(wlan_ng_prism2_header);
 964         strcpy(ph->devname, pAd->net_dev->name);
 965
 966     ph->hosttime.did = DIDmsg_lnxind_wlansniffrm_hosttime;
 967         ph->hosttime.status = 0;
 968         ph->hosttime.len = 4;
 969         ph->hosttime.data = jiffies;
 970
 971         ph->mactime.did = DIDmsg_lnxind_wlansniffrm_mactime;
 972         ph->mactime.status = 0;
 973         ph->mactime.len = 0;
 974         ph->mactime.data = 0;
 975
 976     ph->istx.did = DIDmsg_lnxind_wlansniffrm_istx;
 977         ph->istx.status = 0;
 978         ph->istx.len = 0;
 979         ph->istx.data = 0;
 980
 981     ph->channel.did = DIDmsg_lnxind_wlansniffrm_channel;
 982         ph->channel.status = 0;
 983         ph->channel.len = 4;
 984
 985     ph->channel.data = (u_int32_t)pAd->CommonCfg.Channel;
 986
 987     ph->rssi.did = DIDmsg_lnxind_wlansniffrm_rssi;
 988         ph->rssi.status = 0;
 989         ph->rssi.len = 4;
 990     ph->rssi.data = (u_int32_t)RTMPMaxRssi(pAd, ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI0, RSSI_0), ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI1, RSSI_1), ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI2, RSSI_2));;
 991
 992         ph->signal.did = DIDmsg_lnxind_wlansniffrm_signal;
 993         ph->signal.status = 0;
 994         ph->signal.len = 4;
 995         ph->signal.data = 0; //rssi + noise;
 996
 997         ph->noise.did = DIDmsg_lnxind_wlansniffrm_noise;
 998         ph->noise.status = 0;
 999         ph->noise.len = 4;
1000         ph->noise.data = 0;
1001
1002 #ifdef DOT11_N_SUPPORT
1003     if (pRxBlk->pRxWI->PHYMODE >= MODE_HTMIX)
1004     {
1005         rate_index = 16 + ((UCHAR)pRxBlk->pRxWI->BW *16) + ((UCHAR)pRxBlk->pRxWI->ShortGI *32) + ((UCHAR)pRxBlk->pRxWI->MCS);
1006     }
1007     else
1008 #endif // DOT11_N_SUPPORT //
1009         if (pRxBlk->pRxWI->PHYMODE == MODE_OFDM)
1010         rate_index = (UCHAR)(pRxBlk->pRxWI->MCS) + 4;
1011     else
1012         rate_index = (UCHAR)(pRxBlk->pRxWI->MCS);
1013     if (rate_index < 0)
1014         rate_index = 0;
1015     if (rate_index > 255)
1016         rate_index = 255;
1017
1018         ph->rate.did = DIDmsg_lnxind_wlansniffrm_rate;
1019         ph->rate.status = 0;
1020         ph->rate.len = 4;
1021     ph->rate.data = ralinkrate[rate_index];
1022
1023         ph->frmlen.did = DIDmsg_lnxind_wlansniffrm_frmlen;
1024     ph->frmlen.status = 0;
1025         ph->frmlen.len = 4;
1026         ph->frmlen.data = (u_int32_t)pRxBlk->DataSize;
1027
1028
1029     pOSPkt->pkt_type = PACKET_OTHERHOST;
1030     pOSPkt->protocol = eth_type_trans(pOSPkt, pOSPkt->dev);
1031     pOSPkt->ip_summed = CHECKSUM_NONE;
1032     netif_rx(pOSPkt);
1033
1034     return;
1035
1036 err_free_sk_buff:
1037         RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE);
1038         return;
1039
1040 }
1041 #endif // CONFIG_STA_SUPPORT //
1042
1043
1044 void rtmp_os_thread_init(PUCHAR pThreadName, PVOID pNotify)
1045 {
1046         daemonize(pThreadName /*"%s",pAd->net_dev->name*/);
1047
1048         allow_signal(SIGTERM);
1049         allow_signal(SIGKILL);
1050         current->flags |= PF_NOFREEZE;
1051
1052         /* signal that we've started the thread */
1053         complete(pNotify);
1054 }
1055
1056 void RTMP_IndicateMediaState(
1057         IN      PRTMP_ADAPTER   pAd)
1058 {
1059         if (pAd->CommonCfg.bWirelessEvent)
1060         {
1061                 if (pAd->IndicateMediaState == NdisMediaStateConnected)
1062                 {
1063                         RTMPSendWirelessEvent(pAd, IW_STA_LINKUP_EVENT_FLAG, pAd->MacTab.Content[BSSID_WCID].Addr, BSS0, 0);
1064                 }
1065                 else
1066                 {
1067                         RTMPSendWirelessEvent(pAd, IW_STA_LINKDOWN_EVENT_FLAG, pAd->MacTab.Content[BSSID_WCID].Addr, BSS0, 0);
1068                 }
1069         }
1070 }
1071