~ubuntu-branches/ubuntu/saucy/linux-n900/saucy

// printk("===============>tmp_ht_cap_len is %d,tmp_ht_info_len is %d, tmp_generic_ie_len is %d\n",tmp_ht_cap_len,tmp_ht_info_len,tmp_generic_ie_len);

857

#endif

858

beacon_size = sizeof(struct ieee80211_probe_response)+2+

859

ssid_len

860

+3 //channel

861

+rate_len

862

+rate_ex_len

863

+atim_len

864

+erp_len

865

+wpa_ie_len

866

// +tmp_ht_cap_len

867

// +tmp_ht_info_len

868

// +tmp_generic_ie_len

869

// +wmm_len+2

870

+ieee->tx_headroom;

871

skb = dev_alloc_skb(beacon_size);

872

if (!skb)

873

return NULL;

874

skb_reserve(skb, ieee->tx_headroom);

875

beacon_buf = (struct ieee80211_probe_response*) skb_put(skb, (beacon_size - ieee->tx_headroom));

876

memcpy (beacon_buf->header.addr1, dest,ETH_ALEN);

877

memcpy (beacon_buf->header.addr2, ieee->dev->dev_addr, ETH_ALEN);

878

memcpy (beacon_buf->header.addr3, ieee->current_network.bssid, ETH_ALEN);

879

880

beacon_buf->header.duration_id = 0; //FIXME

881

beacon_buf->beacon_interval =

882

cpu_to_le16(ieee->current_network.beacon_interval);

883

beacon_buf->capability =

884

cpu_to_le16(ieee->current_network.capability & WLAN_CAPABILITY_IBSS);

885

beacon_buf->capability |=

886

cpu_to_le16(ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE); //add short preamble here

887

888

if(ieee->short_slot && (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_SLOT))

889

cpu_to_le16((beacon_buf->capability |= WLAN_CAPABILITY_SHORT_SLOT));

890

891

crypt = ieee->crypt[ieee->tx_keyidx];

892

#if 0

893

encrypt = ieee->host_encrypt && crypt && crypt->ops &&

894

(0 == strcmp(crypt->ops->name, "WEP"));

895

#endif

896

if (encrypt)

897

beacon_buf->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);

898

899

900

beacon_buf->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_PROBE_RESP);

901

beacon_buf->info_element[0].id = MFIE_TYPE_SSID;

902

beacon_buf->info_element[0].len = ssid_len;

903

904

tag = (u8*) beacon_buf->info_element[0].data;

905

906

memcpy(tag, ssid, ssid_len);

907

908

tag += ssid_len;

909

910

*(tag++) = MFIE_TYPE_RATES;

911

*(tag++) = rate_len-2;

912

memcpy(tag,ieee->current_network.rates,rate_len-2);

913

tag+=rate_len-2;

914

915

*(tag++) = MFIE_TYPE_DS_SET;

916

*(tag++) = 1;

917

*(tag++) = ieee->current_network.channel;

918

919

if(atim_len){

920

u16 val16;

921

*(tag++) = MFIE_TYPE_IBSS_SET;

922

*(tag++) = 2;

923

//*((u16*)(tag)) = cpu_to_le16(ieee->current_network.atim_window);

924

val16 = cpu_to_le16(ieee->current_network.atim_window);

925

memcpy((u8 *)tag, (u8 *)&val16, 2);

926

tag+=2;

927

}

928

929

if(erp_len){

930

*(tag++) = MFIE_TYPE_ERP;

931

*(tag++) = 1;

932

*(tag++) = erpinfo_content;

933

}

934

#if 0

935

//Include High Throuput capability

936

937

*(tag++) = MFIE_TYPE_HT_CAP;

938

*(tag++) = tmp_ht_cap_len - 2;

939

memcpy(tag, tmp_ht_cap_buf, tmp_ht_cap_len - 2);

940

tag += tmp_ht_cap_len - 2;

941

#endif

942

if(rate_ex_len){

943

*(tag++) = MFIE_TYPE_RATES_EX;

944

*(tag++) = rate_ex_len-2;

945

memcpy(tag,ieee->current_network.rates_ex,rate_ex_len-2);

946

tag+=rate_ex_len-2;

947

}

948

949

#if 0

950

//Include High Throuput info

951

952

*(tag++) = MFIE_TYPE_HT_INFO;

953

*(tag++) = tmp_ht_info_len - 2;

954

memcpy(tag, tmp_ht_info_buf, tmp_ht_info_len -2);

955

tag += tmp_ht_info_len - 2;

956

#endif

957

if (wpa_ie_len)

958

{

959

if (ieee->iw_mode == IW_MODE_ADHOC)

960

{//as Windows will set pairwise key same as the group key which is not allowed in Linux, so set this for IOT issue. WB 2008.07.07

961

memcpy(&ieee->wpa_ie[14], &ieee->wpa_ie[8], 4);

962

}

963

memcpy(tag, ieee->wpa_ie, ieee->wpa_ie_len);

964

tag += wpa_ie_len;

965

}

966

967

#if 0

968

969

// Construct Realtek Proprietary Aggregation mode (Set AMPDU Factor to 2, 32k)

970

971

if(pHTInfo->bRegRT2RTAggregation)

972

{

973

(*tag++) = 0xdd;

974

(*tag++) = tmp_generic_ie_len - 2;

975

memcpy(tag,tmp_generic_ie_buf,tmp_generic_ie_len -2);

976

tag += tmp_generic_ie_len -2;

977

978

}

979

#endif

980

#if 0

981

if(ieee->qos_support)

982

{

983

(*tag++) = 0xdd;

984

(*tag++) = wmm_len;

985

memcpy(tag,QosOui,wmm_len);

986

tag += wmm_len;

987

}

988

#endif

989

//skb->dev = ieee->dev;

990

return skb;

991

}

992

993

994

struct sk_buff* ieee80211_assoc_resp(struct ieee80211_device *ieee, u8 *dest)

995

{

996

struct sk_buff *skb;

997

u8* tag;

998

999

struct ieee80211_crypt_data* crypt;

1000

struct ieee80211_assoc_response_frame *assoc;

1001

short encrypt;

1002

1003

unsigned int rate_len = ieee80211_MFIE_rate_len(ieee);

1004

int len = sizeof(struct ieee80211_assoc_response_frame) + rate_len + ieee->tx_headroom;

1005

1006

skb = dev_alloc_skb(len);

1007

1008

if (!skb)

1009

return NULL;

1010

1011

skb_reserve(skb, ieee->tx_headroom);

1012

1013

assoc = (struct ieee80211_assoc_response_frame *)

1014

skb_put(skb,sizeof(struct ieee80211_assoc_response_frame));

1015

1016

assoc->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP);

1017

memcpy(assoc->header.addr1, dest,ETH_ALEN);

1018

memcpy(assoc->header.addr3, ieee->dev->dev_addr, ETH_ALEN);

1019

memcpy(assoc->header.addr2, ieee->dev->dev_addr, ETH_ALEN);

1020

assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ?

1021

WLAN_CAPABILITY_BSS : WLAN_CAPABILITY_IBSS);

1022

1023

1024

if(ieee->short_slot)

1025

assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT);

1026

1027

if (ieee->host_encrypt)

1028

crypt = ieee->crypt[ieee->tx_keyidx];

1029

else crypt = NULL;

1030

1031

encrypt = ( crypt && crypt->ops);

1032

1033

if (encrypt)

1034

assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);

1035

1036

assoc->status = 0;

1037

assoc->aid = cpu_to_le16(ieee->assoc_id);

1038

if (ieee->assoc_id == 0x2007) ieee->assoc_id=0;

1039

else ieee->assoc_id++;

1040

1041

tag = (u8*) skb_put(skb, rate_len);

1042

1043

ieee80211_MFIE_Brate(ieee, &tag);

1044

ieee80211_MFIE_Grate(ieee, &tag);

1045

1046

return skb;

1047

}

1048

1049

struct sk_buff* ieee80211_auth_resp(struct ieee80211_device *ieee,int status, u8 *dest)

1050

{

1051

struct sk_buff *skb;

1052

struct ieee80211_authentication *auth;

1053

int len = ieee->tx_headroom + sizeof(struct ieee80211_authentication)+1;

1054

1055

skb = dev_alloc_skb(len);

1056

1057

if (!skb)

1058

return NULL;

1059

1060

skb->len = sizeof(struct ieee80211_authentication);

1061

1062

auth = (struct ieee80211_authentication *)skb->data;

1063

1064

auth->status = cpu_to_le16(status);

1065

auth->transaction = cpu_to_le16(2);

1066

auth->algorithm = cpu_to_le16(WLAN_AUTH_OPEN);

1067

1068

memcpy(auth->header.addr3, ieee->dev->dev_addr, ETH_ALEN);

1069

memcpy(auth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);

1070

memcpy(auth->header.addr1, dest, ETH_ALEN);

1071

auth->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_AUTH);

1072

return skb;

1073

1074

1075

}

1076

1077

struct sk_buff* ieee80211_null_func(struct ieee80211_device *ieee,short pwr)

1078

{

1079

struct sk_buff *skb;

1080

struct ieee80211_hdr_3addr* hdr;

1081

1082

skb = dev_alloc_skb(sizeof(struct ieee80211_hdr_3addr));

1083

1084

if (!skb)

1085

return NULL;

1086

1087

hdr = (struct ieee80211_hdr_3addr*)skb_put(skb,sizeof(struct ieee80211_hdr_3addr));

1088

1089

memcpy(hdr->addr1, ieee->current_network.bssid, ETH_ALEN);

1090

memcpy(hdr->addr2, ieee->dev->dev_addr, ETH_ALEN);

1091

memcpy(hdr->addr3, ieee->current_network.bssid, ETH_ALEN);

1092

1093

hdr->frame_ctl = cpu_to_le16(IEEE80211_FTYPE_DATA |

1094

IEEE80211_STYPE_NULLFUNC | IEEE80211_FCTL_TODS |

1095

(pwr ? IEEE80211_FCTL_PM:0));

1096

1097

return skb;

1098

1099

1100

}

1101

1102

struct sk_buff* ieee80211_pspoll_func(struct ieee80211_device *ieee)

1103

{

1104

struct sk_buff *skb;

1105

struct ieee80211_pspoll_hdr* hdr;

1106

1107

#ifdef USB_USE_ALIGNMENT

1108

u32 Tmpaddr=0;

1109

int alignment=0;

1110

skb = dev_alloc_skb(sizeof(struct ieee80211_pspoll_hdr) + ieee->tx_headroom + USB_512B_ALIGNMENT_SIZE);

1111

#else

1112

skb = dev_alloc_skb(sizeof(struct ieee80211_pspoll_hdr)+ieee->tx_headroom);

1113

#endif

1114

if (!skb)

1115

return NULL;

1116

1117

#ifdef USB_USE_ALIGNMENT

1118

Tmpaddr = (u32)skb->data;

1119

alignment = Tmpaddr & 0x1ff;

1120

skb_reserve(skb,(USB_512B_ALIGNMENT_SIZE - alignment));

1121

#endif

1122

skb_reserve(skb, ieee->tx_headroom);

1123

1124

hdr = (struct ieee80211_pspoll_hdr*)skb_put(skb,sizeof(struct ieee80211_pspoll_hdr));

1125

1126

memcpy(hdr->bssid, ieee->current_network.bssid, ETH_ALEN);

1127

memcpy(hdr->ta, ieee->dev->dev_addr, ETH_ALEN);

1128

1129

hdr->aid = cpu_to_le16(ieee->assoc_id | 0xc000);

1130

hdr->frame_ctl = cpu_to_le16(IEEE80211_FTYPE_CTL |IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM);

1131

1132

return skb;

1133

1134

}

1135

1136

1137

void ieee80211_resp_to_assoc_rq(struct ieee80211_device *ieee, u8* dest)

1138

{

1139

struct sk_buff *buf = ieee80211_assoc_resp(ieee, dest);

1140

1141

if (buf)

1142

softmac_mgmt_xmit(buf, ieee);

1143

}

1144

1145

1146

void ieee80211_resp_to_auth(struct ieee80211_device *ieee, int s, u8* dest)

1147

{

1148

struct sk_buff *buf = ieee80211_auth_resp(ieee, s, dest);

1149

1150

if (buf)

1151

softmac_mgmt_xmit(buf, ieee);

1152

}

1153

1154

1155

void ieee80211_resp_to_probe(struct ieee80211_device *ieee, u8 *dest)

1156

{

1157

1158

1159

struct sk_buff *buf = ieee80211_probe_resp(ieee, dest);

1160

if (buf)

1161

softmac_mgmt_xmit(buf, ieee);

1162

}

1163

1164

1165

inline struct sk_buff *ieee80211_association_req(struct ieee80211_network *beacon,struct ieee80211_device *ieee)

1166

{

1167

struct sk_buff *skb;

1168

//unsigned long flags;

1169

1170

struct ieee80211_assoc_request_frame *hdr;

1171

u8 *tag;//,*rsn_ie;

1172

//short info_addr = 0;

1173

//int i;

1174

//u16 suite_count = 0;

1175

//u8 suit_select = 0;

1176

//unsigned int wpa_len = beacon->wpa_ie_len;

1177

//for HT

1178

u8* ht_cap_buf = NULL;

1179

u8 ht_cap_len=0;

1180

u8* realtek_ie_buf=NULL;

1181

u8 realtek_ie_len=0;

1182

int wpa_ie_len= ieee->wpa_ie_len;

1183

unsigned int ckip_ie_len=0;

1184

unsigned int ccxrm_ie_len=0;

1185

unsigned int cxvernum_ie_len=0;

1186

struct ieee80211_crypt_data* crypt;

1187

int encrypt;

1188

1189

unsigned int rate_len = ieee80211_MFIE_rate_len(ieee);

1190

unsigned int wmm_info_len = beacon->qos_data.supported?9:0;

1191

#ifdef THOMAS_TURBO

1192

unsigned int turbo_info_len = beacon->Turbo_Enable?9:0;

1193

#endif

1194

1195

int len = 0;

1196

1197

crypt = ieee->crypt[ieee->tx_keyidx];

1198

encrypt = ieee->host_encrypt && crypt && crypt->ops && ((0 == strcmp(crypt->ops->name,"WEP") || wpa_ie_len));

1199

1200

//Include High Throuput capability && Realtek proprietary

1201

if(ieee->pHTInfo->bCurrentHTSupport&&ieee->pHTInfo->bEnableHT)

1202

{

1203

ht_cap_buf = (u8*)&(ieee->pHTInfo->SelfHTCap);

1204

ht_cap_len = sizeof(ieee->pHTInfo->SelfHTCap);

1205

HTConstructCapabilityElement(ieee, ht_cap_buf, &ht_cap_len, encrypt);

1206

if(ieee->pHTInfo->bCurrentRT2RTAggregation)

1207

{

1208

realtek_ie_buf = ieee->pHTInfo->szRT2RTAggBuffer;

1209

realtek_ie_len = sizeof( ieee->pHTInfo->szRT2RTAggBuffer);

1210

HTConstructRT2RTAggElement(ieee, realtek_ie_buf, &realtek_ie_len);

1211

1212

}

1213

}

1214

if(ieee->qos_support){

1215

wmm_info_len = beacon->qos_data.supported?9:0;

1216

}

1217

1218

1219

if(beacon->bCkipSupported)

1220

{

1221

ckip_ie_len = 30+2;

1222

}

1223

if(beacon->bCcxRmEnable)

1224

{

1225

ccxrm_ie_len = 6+2;

1226

}

1227

if( beacon->BssCcxVerNumber >= 2 )

1228

{

1229

cxvernum_ie_len = 5+2;

1230

}

1231

#ifdef THOMAS_TURBO

1232

len = sizeof(struct ieee80211_assoc_request_frame)+ 2

1233

+ beacon->ssid_len//essid tagged val

1234

+ rate_len//rates tagged val

1235

+ wpa_ie_len

1236

+ wmm_info_len

1237

+ turbo_info_len

1238

+ ht_cap_len

1239

+ realtek_ie_len

1240

+ ckip_ie_len

1241

+ ccxrm_ie_len

1242

+ cxvernum_ie_len

1243

+ ieee->tx_headroom;

1244

#else

1245

len = sizeof(struct ieee80211_assoc_request_frame)+ 2

1246

+ beacon->ssid_len//essid tagged val

1247

+ rate_len//rates tagged val

1248

+ wpa_ie_len

1249

+ wmm_info_len

1250

+ ht_cap_len

1251

+ realtek_ie_len

1252

+ ckip_ie_len

1253

+ ccxrm_ie_len

1254

+ cxvernum_ie_len

1255

+ ieee->tx_headroom;

1256

#endif

1257

1258

skb = dev_alloc_skb(len);

1259

1260

if (!skb)

1261

return NULL;

1262

1263

skb_reserve(skb, ieee->tx_headroom);

1264

1265

hdr = (struct ieee80211_assoc_request_frame *)

1266

skb_put(skb, sizeof(struct ieee80211_assoc_request_frame)+2);

1267

1268

1269

hdr->header.frame_ctl = IEEE80211_STYPE_ASSOC_REQ;

1270

hdr->header.duration_id= 37; //FIXME

1271

memcpy(hdr->header.addr1, beacon->bssid, ETH_ALEN);

1272

memcpy(hdr->header.addr2, ieee->dev->dev_addr, ETH_ALEN);

1273

memcpy(hdr->header.addr3, beacon->bssid, ETH_ALEN);

1274

1275

memcpy(ieee->ap_mac_addr, beacon->bssid, ETH_ALEN);//for HW security, John

1276

1277

hdr->capability = cpu_to_le16(WLAN_CAPABILITY_BSS);

1278

if (beacon->capability & WLAN_CAPABILITY_PRIVACY )

1279

hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);

1280

1281

if (beacon->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)

1282

hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE); //add short_preamble here

1283

1284

if(ieee->short_slot)

1285

hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT);

1286

if (wmm_info_len) //QOS

1287

hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_QOS);

1288

1289

hdr->listen_interval = 0xa; //FIXME

1290

1291

hdr->info_element[0].id = MFIE_TYPE_SSID;

1292

1293

hdr->info_element[0].len = beacon->ssid_len;

1294

tag = skb_put(skb, beacon->ssid_len);

1295

memcpy(tag, beacon->ssid, beacon->ssid_len);

1296

1297

tag = skb_put(skb, rate_len);

1298

1299

ieee80211_MFIE_Brate(ieee, &tag);

1300

ieee80211_MFIE_Grate(ieee, &tag);

1301

// For CCX 1 S13, CKIP. Added by Annie, 2006-08-14.

1302

if( beacon->bCkipSupported )

1303

{

1304

static u8 AironetIeOui[] = {0x00, 0x01, 0x66}; // "4500-client"

1305

u8 CcxAironetBuf[30];

1306

OCTET_STRING osCcxAironetIE;

1307

1308

memset(CcxAironetBuf, 0,30);

1309

osCcxAironetIE.Octet = CcxAironetBuf;

1310

osCcxAironetIE.Length = sizeof(CcxAironetBuf);

1311

1312

// Ref. CCX test plan v3.61, 3.2.3.1 step 13.

1313

// We want to make the device type as "4500-client". 060926, by CCW.

1314

1315

memcpy(osCcxAironetIE.Octet, AironetIeOui, sizeof(AironetIeOui));

1316

1317

// CCX1 spec V1.13, A01.1 CKIP Negotiation (page23):

1318

// "The CKIP negotiation is started with the associate request from the client to the access point,

1319

// containing an Aironet element with both the MIC and KP bits set."

1320

osCcxAironetIE.Octet[IE_CISCO_FLAG_POSITION] |= (SUPPORT_CKIP_PK|SUPPORT_CKIP_MIC) ;

1321

tag = skb_put(skb, ckip_ie_len);

1322

*tag++ = MFIE_TYPE_AIRONET;

1323

*tag++ = osCcxAironetIE.Length;

1324

memcpy(tag,osCcxAironetIE.Octet,osCcxAironetIE.Length);

1325

tag += osCcxAironetIE.Length;

1326

}

1327

1328

if(beacon->bCcxRmEnable)

1329

{

1330

static u8 CcxRmCapBuf[] = {0x00, 0x40, 0x96, 0x01, 0x01, 0x00};

1331

OCTET_STRING osCcxRmCap;

1332

1333

osCcxRmCap.Octet = CcxRmCapBuf;

1334

osCcxRmCap.Length = sizeof(CcxRmCapBuf);

1335

tag = skb_put(skb,ccxrm_ie_len);

1336

*tag++ = MFIE_TYPE_GENERIC;

1337

*tag++ = osCcxRmCap.Length;

1338

memcpy(tag,osCcxRmCap.Octet,osCcxRmCap.Length);

1339

tag += osCcxRmCap.Length;

1340

}

1341

1342

if( beacon->BssCcxVerNumber >= 2 )

1343

{

1344

u8 CcxVerNumBuf[] = {0x00, 0x40, 0x96, 0x03, 0x00};

1345

OCTET_STRING osCcxVerNum;

1346

CcxVerNumBuf[4] = beacon->BssCcxVerNumber;

1347

osCcxVerNum.Octet = CcxVerNumBuf;

1348

osCcxVerNum.Length = sizeof(CcxVerNumBuf);

1349

tag = skb_put(skb,cxvernum_ie_len);

1350

*tag++ = MFIE_TYPE_GENERIC;

1351

*tag++ = osCcxVerNum.Length;

1352

memcpy(tag,osCcxVerNum.Octet,osCcxVerNum.Length);

1353

tag += osCcxVerNum.Length;

1354

}

1355

//HT cap element

1356

if(ieee->pHTInfo->bCurrentHTSupport&&ieee->pHTInfo->bEnableHT){

1357

if(ieee->pHTInfo->ePeerHTSpecVer != HT_SPEC_VER_EWC)

1358

{

1359

tag = skb_put(skb, ht_cap_len);

1360

*tag++ = MFIE_TYPE_HT_CAP;

1361

*tag++ = ht_cap_len - 2;

1362

memcpy(tag, ht_cap_buf,ht_cap_len -2);

1363

tag += ht_cap_len -2;

1364

}

1365

}

1366

1367

1368

//choose what wpa_supplicant gives to associate.

1369

tag = skb_put(skb, wpa_ie_len);

1370

if (wpa_ie_len){

1371

memcpy(tag, ieee->wpa_ie, ieee->wpa_ie_len);

1372

}

1373

1374

tag = skb_put(skb,wmm_info_len);

1375

if(wmm_info_len) {

1376

ieee80211_WMM_Info(ieee, &tag);

1377

}

1378

#ifdef THOMAS_TURBO

1379

tag = skb_put(skb,turbo_info_len);

1380

if(turbo_info_len) {

1381

ieee80211_TURBO_Info(ieee, &tag);

1382

}

1383

#endif

1384

1385

if(ieee->pHTInfo->bCurrentHTSupport&&ieee->pHTInfo->bEnableHT){

1386

if(ieee->pHTInfo->ePeerHTSpecVer == HT_SPEC_VER_EWC)

1387

{

1388

tag = skb_put(skb, ht_cap_len);

1389

*tag++ = MFIE_TYPE_GENERIC;

1390

*tag++ = ht_cap_len - 2;

1391

memcpy(tag, ht_cap_buf,ht_cap_len - 2);

1392

tag += ht_cap_len -2;

1393

}

1394

1395

if(ieee->pHTInfo->bCurrentRT2RTAggregation){

1396

tag = skb_put(skb, realtek_ie_len);

1397

*tag++ = MFIE_TYPE_GENERIC;

1398

*tag++ = realtek_ie_len - 2;

1399

memcpy(tag, realtek_ie_buf,realtek_ie_len -2 );

1400

}

1401

}

1402

// printk("<=====%s(), %p, %p\n", __FUNCTION__, ieee->dev, ieee->dev->dev_addr);

1403

// IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA, skb->data, skb->len);

1404

return skb;

1405

}

1406

1407

void ieee80211_associate_abort(struct ieee80211_device *ieee)

1408

{

1409

1410

unsigned long flags;

1411

spin_lock_irqsave(&ieee->lock, flags);

1412

1413

ieee->associate_seq++;

1414

1415

/* don't scan, and avoid to have the RX path possibily

1416

* try again to associate. Even do not react to AUTH or

1417

* ASSOC response. Just wait for the retry wq to be scheduled.

1418

* Here we will check if there are good nets to associate

1419

* with, so we retry or just get back to NO_LINK and scanning

1420

1421

if (ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATING){

1422

IEEE80211_DEBUG_MGMT("Authentication failed\n");

1423

ieee->softmac_stats.no_auth_rs++;

1424

}else{

1425

IEEE80211_DEBUG_MGMT("Association failed\n");

1426

ieee->softmac_stats.no_ass_rs++;

1427

}

1428

1429

ieee->state = IEEE80211_ASSOCIATING_RETRY;

1430

1431

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

1432

queue_delayed_work(ieee->wq, &ieee->associate_retry_wq, \

1433

IEEE80211_SOFTMAC_ASSOC_RETRY_TIME);

1434

#else

1435

schedule_task(&ieee->associate_retry_wq);

1436

#endif

1437

1438

spin_unlock_irqrestore(&ieee->lock, flags);

1439

}

1440

1441

void ieee80211_associate_abort_cb(unsigned long dev)

1442

{

1443

ieee80211_associate_abort((struct ieee80211_device *) dev);

1444

}

1445

1446

1447

void ieee80211_associate_step1(struct ieee80211_device *ieee)

1448

{

1449

struct ieee80211_network *beacon = &ieee->current_network;

1450

struct sk_buff *skb;

1451

1452

IEEE80211_DEBUG_MGMT("Stopping scan\n");

1453

1454

ieee->softmac_stats.tx_auth_rq++;

1455

skb=ieee80211_authentication_req(beacon, ieee, 0);

1456

1457

if (!skb)

1458

ieee80211_associate_abort(ieee);

1459

else{

1460

ieee->state = IEEE80211_ASSOCIATING_AUTHENTICATING ;

1461

IEEE80211_DEBUG_MGMT("Sending authentication request\n");

1462

//printk(KERN_WARNING "Sending authentication request\n");

1463

softmac_mgmt_xmit(skb, ieee);

1464

//BUGON when you try to add_timer twice, using mod_timer may be better, john0709

1465

if(!timer_pending(&ieee->associate_timer)){

1466

ieee->associate_timer.expires = jiffies + (HZ / 2);

1467

add_timer(&ieee->associate_timer);

1468

}

1469

//dev_kfree_skb_any(skb);//edit by thomas

1470

}

1471

}

1472

1473

void ieee80211_rtl_auth_challenge(struct ieee80211_device *ieee, u8 *challenge, int chlen)

1474

{

1475

u8 *c;

1476

struct sk_buff *skb;

1477

struct ieee80211_network *beacon = &ieee->current_network;

1478

// int hlen = sizeof(struct ieee80211_authentication);

1479

1480

ieee->associate_seq++;

1481

ieee->softmac_stats.tx_auth_rq++;

1482

1483

skb = ieee80211_authentication_req(beacon, ieee, chlen+2);

1484

if (!skb)

1485

ieee80211_associate_abort(ieee);

1486

else{

1487

c = skb_put(skb, chlen+2);

1488

*(c++) = MFIE_TYPE_CHALLENGE;

1489

*(c++) = chlen;

1490

memcpy(c, challenge, chlen);

1491

1492

IEEE80211_DEBUG_MGMT("Sending authentication challenge response\n");

1493

1494

ieee80211_encrypt_fragment(ieee, skb, sizeof(struct ieee80211_hdr_3addr ));

1495

1496

softmac_mgmt_xmit(skb, ieee);

1497

mod_timer(&ieee->associate_timer, jiffies + (HZ/2));

1498

#if 0

1499

ieee->associate_timer.expires = jiffies + (HZ / 2);

1500

add_timer(&ieee->associate_timer);

1501

#endif

1502

//dev_kfree_skb_any(skb);//edit by thomas

1503

}

1504

kfree(challenge);

1505

}

1506

1507

void ieee80211_associate_step2(struct ieee80211_device *ieee)

1508

{

1509

struct sk_buff* skb;

1510

struct ieee80211_network *beacon = &ieee->current_network;

1511

1512

del_timer_sync(&ieee->associate_timer);

1513

1514

IEEE80211_DEBUG_MGMT("Sending association request\n");

1515

1516

ieee->softmac_stats.tx_ass_rq++;

1517

skb=ieee80211_association_req(beacon, ieee);

1518

if (!skb)

1519

ieee80211_associate_abort(ieee);

1520

else{

1521

softmac_mgmt_xmit(skb, ieee);

1522

mod_timer(&ieee->associate_timer, jiffies + (HZ/2));

1523

#if 0

1524

ieee->associate_timer.expires = jiffies + (HZ / 2);

1525

add_timer(&ieee->associate_timer);

1526

#endif

1527

//dev_kfree_skb_any(skb);//edit by thomas

1528

}

1529

}

1530

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))

1531

void ieee80211_associate_complete_wq(struct work_struct *work)

1532

{

1533

struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, associate_complete_wq);

1534

#else

1535

void ieee80211_associate_complete_wq(struct ieee80211_device *ieee)

1536

{

1537

#endif

1538

printk(KERN_INFO "Associated successfully\n");

1539

ieee->is_roaming = false;

1540

if(ieee80211_is_54g(ieee->current_network) &&

1541

(ieee->modulation & IEEE80211_OFDM_MODULATION)){

1542

1543

ieee->rate = 108;

1544

printk(KERN_INFO"Using G rates:%d\n", ieee->rate);

1545

}else{

1546

ieee->rate = 22;

1547

printk(KERN_INFO"Using B rates:%d\n", ieee->rate);

1548

}

1549

if (ieee->pHTInfo->bCurrentHTSupport&&ieee->pHTInfo->bEnableHT)

1550

{

1551

printk("Successfully associated, ht enabled\n");

1552

HTOnAssocRsp(ieee);

1553

}

1554

else

1555

{

1556

printk("Successfully associated, ht not enabled(%d, %d)\n", ieee->pHTInfo->bCurrentHTSupport, ieee->pHTInfo->bEnableHT);

1557

memset(ieee->dot11HTOperationalRateSet, 0, 16);

1558

//HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);

1559

}

1560

ieee->LinkDetectInfo.SlotNum = 2 * (1 + ieee->current_network.beacon_interval/500);

1561

// To prevent the immediately calling watch_dog after association.

1562

if(ieee->LinkDetectInfo.NumRecvBcnInPeriod==0||ieee->LinkDetectInfo.NumRecvDataInPeriod==0 )

1563

{

1564

ieee->LinkDetectInfo.NumRecvBcnInPeriod = 1;

1565

ieee->LinkDetectInfo.NumRecvDataInPeriod= 1;

1566

}

1567

ieee->link_change(ieee->dev);

1568

if(ieee->is_silent_reset == 0){

1569

printk("============>normal associate\n");

1570

notify_wx_assoc_event(ieee);

1571

}

1572

else if(ieee->is_silent_reset == 1)

1573

{

1574

printk("==================>silent reset associate\n");

1575

ieee->is_silent_reset = 0;

1576

}

1577

1578

if (ieee->data_hard_resume)

1579

ieee->data_hard_resume(ieee->dev);

1580

netif_carrier_on(ieee->dev);

1581

}

1582

1583

void ieee80211_associate_complete(struct ieee80211_device *ieee)

1584

{

1585

// int i;

1586

// struct net_device* dev = ieee->dev;

1587

del_timer_sync(&ieee->associate_timer);

1588

1589

#if 0

1590

for(i = 0; i < 6; i++) {

1591

ieee->seq_ctrl[i] = 0;

1592

}

1593

#endif

1594

ieee->state = IEEE80211_LINKED;

1595

#if 0

1596

if (ieee->pHTInfo->bCurrentHTSupport)

1597

{

1598

printk("Successfully associated, ht enabled\n");

1599

queue_work(ieee->wq, &ieee->ht_onAssRsp);

1600

}

1601

else

1602

{

1603

printk("Successfully associated, ht not enabled\n");

1604

memset(ieee->dot11HTOperationalRateSet, 0, 16);

1605

HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);

1606

}

1607

#endif

1608

//ieee->UpdateHalRATRTableHandler(dev, ieee->dot11HTOperationalRateSet);

1609

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

1610

queue_work(ieee->wq, &ieee->associate_complete_wq);

1611

#else

1612

schedule_task(&ieee->associate_complete_wq);

1613

#endif

1614

}

1615

1616

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))

1617

void ieee80211_associate_procedure_wq(struct work_struct *work)

1618

{

1619

struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, associate_procedure_wq);

1620

#else

1621

void ieee80211_associate_procedure_wq(struct ieee80211_device *ieee)

1622

{

1623

#endif

1624

ieee->sync_scan_hurryup = 1;

1625

#ifdef ENABLE_IPS

1626

if(ieee->ieee80211_ips_leave != NULL)

1627

ieee->ieee80211_ips_leave(ieee->dev);

1628

#endif

1629

1630

down(&ieee->wx_sem);

1631

1632

if (ieee->data_hard_stop)

1633

ieee->data_hard_stop(ieee->dev);

1634

1635

ieee80211_stop_scan(ieee);

1636

printk("===>%s(), chan:%d\n", __FUNCTION__, ieee->current_network.channel);

1637

//ieee->set_chan(ieee->dev, ieee->current_network.channel);

1638

HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);

1639

1640

#ifdef ENABLE_IPS

1641

if(ieee->eRFPowerState == eRfOff)

1642

{

1643

if(ieee->ieee80211_ips_leave_wq != NULL)

1644

ieee->ieee80211_ips_leave_wq(ieee->dev);

1645

1646

up(&ieee->wx_sem);

1647

return;

1648

}

1649

#endif

1650

1651

ieee->associate_seq = 1;

1652

ieee80211_associate_step1(ieee);

1653

1654

up(&ieee->wx_sem);

1655

}

1656

1657

inline void ieee80211_softmac_new_net(struct ieee80211_device *ieee, struct ieee80211_network *net)

1658

{

1659

u8 tmp_ssid[IW_ESSID_MAX_SIZE+1];

1660

int tmp_ssid_len = 0;

1661

1662

short apset,ssidset,ssidbroad,apmatch,ssidmatch;

1663

1664

/* we are interested in new new only if we are not associated

1665

* and we are not associating / authenticating

1666

1667

if (ieee->state != IEEE80211_NOLINK)

1668

return;

1669

1670

if ((ieee->iw_mode == IW_MODE_INFRA) && !(net->capability & WLAN_CAPABILITY_BSS))

1671

return;

1672

1673

if ((ieee->iw_mode == IW_MODE_ADHOC) && !(net->capability & WLAN_CAPABILITY_IBSS))

1674

return;

1675

1676

1677

if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC){

1678

/* if the user specified the AP MAC, we need also the essid

1679

* This could be obtained by beacons or, if the network does not

1680

* broadcast it, it can be put manually.

1681

1682

apset = ieee->wap_set;//(memcmp(ieee->current_network.bssid, zero,ETH_ALEN)!=0 );

1683

ssidset = ieee->ssid_set;//ieee->current_network.ssid[0] != '\0';

1684

ssidbroad = !(net->ssid_len == 0 || net->ssid[0]== '\0');

1685

apmatch = (memcmp(ieee->current_network.bssid, net->bssid, ETH_ALEN)==0);

1686

ssidmatch = (ieee->current_network.ssid_len == net->ssid_len)&&\

1687

(!strncmp(ieee->current_network.ssid, net->ssid, net->ssid_len));

1688

1689

1690

if ( /* if the user set the AP check if match.

1691

* if the network does not broadcast essid we check the user supplyed ANY essid

1692

* if the network does broadcast and the user does not set essid it is OK

1693

* if the network does broadcast and the user did set essid chech if essid match

1694

1695

( apset && apmatch &&

1696

((ssidset && ssidbroad && ssidmatch) || (ssidbroad && !ssidset) || (!ssidbroad && ssidset)) ) ||

1697

/* if the ap is not set, check that the user set the bssid

1698

* and the network does bradcast and that those two bssid matches

1699

1700

(!apset && ssidset && ssidbroad && ssidmatch)

1701

){

1702

/* if the essid is hidden replace it with the

1703

* essid provided by the user.

1704

1705

if (!ssidbroad){

1706

strncpy(tmp_ssid, ieee->current_network.ssid, IW_ESSID_MAX_SIZE);

1707

tmp_ssid_len = ieee->current_network.ssid_len;

1708

}

1709

memcpy(&ieee->current_network, net, sizeof(struct ieee80211_network));

1710

1711

if (!ssidbroad){

1712

strncpy(ieee->current_network.ssid, tmp_ssid, IW_ESSID_MAX_SIZE);

1713

ieee->current_network.ssid_len = tmp_ssid_len;

1714

}

1715

printk(KERN_INFO"Linking with %s,channel:%d, qos:%d, myHT:%d, networkHT:%d\n",ieee->current_network.ssid,ieee->current_network.channel, ieee->current_network.qos_data.supported, ieee->pHTInfo->bEnableHT, ieee->current_network.bssht.bdSupportHT);

1716

1717

//ieee->pHTInfo->IOTAction = 0;

1718

HTResetIOTSetting(ieee->pHTInfo);

1719

if (ieee->iw_mode == IW_MODE_INFRA){

1720

/* Join the network for the first time */

1721

ieee->AsocRetryCount = 0;

1722

//for HT by amy 080514

1723

if((ieee->current_network.qos_data.supported == 1) &&

1724

// (ieee->pHTInfo->bEnableHT && ieee->current_network.bssht.bdSupportHT))

1725

ieee->current_network.bssht.bdSupportHT)

1726

/*WB, 2008.09.09:bCurrentHTSupport and bEnableHT two flags are going to put together to check whether we are in HT now, so needn't to check bEnableHT flags here. That's is to say we will set to HT support whenever joined AP has the ability to support HT. And whether we are in HT or not, please check bCurrentHTSupport&&bEnableHT now please.*/

1727

{

1728

// ieee->pHTInfo->bCurrentHTSupport = true;

1729

HTResetSelfAndSavePeerSetting(ieee, &(ieee->current_network));

1730

}

1731

else

1732

{

1733

ieee->pHTInfo->bCurrentHTSupport = false;

1734

}

1735

1736

ieee->state = IEEE80211_ASSOCIATING;

1737

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

1738

queue_work(ieee->wq, &ieee->associate_procedure_wq);

1739

#else

1740

schedule_task(&ieee->associate_procedure_wq);

1741

#endif

1742

}else{

1743

if(ieee80211_is_54g(ieee->current_network) &&

1744

(ieee->modulation & IEEE80211_OFDM_MODULATION)){

1745

ieee->rate = 108;

1746

ieee->SetWirelessMode(ieee->dev, IEEE_G);

1747

printk(KERN_INFO"Using G rates\n");

1748

}else{

1749

ieee->rate = 22;

1750

ieee->SetWirelessMode(ieee->dev, IEEE_B);

1751

printk(KERN_INFO"Using B rates\n");

1752

}

1753

memset(ieee->dot11HTOperationalRateSet, 0, 16);

1754

//HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);

1755

ieee->state = IEEE80211_LINKED;

1756

}

1757

1758

}

1759

}

1760

1761

}

1762

1763

void ieee80211_softmac_check_all_nets(struct ieee80211_device *ieee)

1764

{

1765

unsigned long flags;

1766

struct ieee80211_network *target;

1767

1768

spin_lock_irqsave(&ieee->lock, flags);

1769

1770

list_for_each_entry(target, &ieee->network_list, list) {

1771

1772

/* if the state become different that NOLINK means

1773

* we had found what we are searching for

1774

1775

1776

if (ieee->state != IEEE80211_NOLINK)

1777

break;

1778

1779

if (ieee->scan_age == 0 || time_after(target->last_scanned + ieee->scan_age, jiffies))

1780

ieee80211_softmac_new_net(ieee, target);

1781

}

1782

1783

spin_unlock_irqrestore(&ieee->lock, flags);

1784

1785

}

1786

1787

1788

static inline u16 auth_parse(struct sk_buff *skb, u8** challenge, int *chlen)

1789

{

1790

struct ieee80211_authentication *a;

1791

u8 *t;

1792

if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){

1793

IEEE80211_DEBUG_MGMT("invalid len in auth resp: %d\n",skb->len);

1794

return 0xcafe;

1795

}

1796

*challenge = NULL;

1797

a = (struct ieee80211_authentication*) skb->data;

1798

if(skb->len > (sizeof(struct ieee80211_authentication) +3)){

1799

t = skb->data + sizeof(struct ieee80211_authentication);

1800

1801

if(*(t++) == MFIE_TYPE_CHALLENGE){

1802

*chlen = *(t++);

1803

*challenge = kmalloc(*chlen, GFP_ATOMIC);

1804

memcpy(*challenge, t, *chlen);

1805

}

1806

}

1807

1808

return cpu_to_le16(a->status);

1809

1810

}

1811

1812

1813

int auth_rq_parse(struct sk_buff *skb,u8* dest)

1814

{

1815

struct ieee80211_authentication *a;

1816

1817

if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){

1818

IEEE80211_DEBUG_MGMT("invalid len in auth request: %d\n",skb->len);

1819

return -1;

1820

}

1821

a = (struct ieee80211_authentication*) skb->data;

1822

1823

memcpy(dest,a->header.addr2, ETH_ALEN);

1824

1825

if (le16_to_cpu(a->algorithm) != WLAN_AUTH_OPEN)

1826

return WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG;

1827

1828

return WLAN_STATUS_SUCCESS;

1829

}

1830

1831

static short probe_rq_parse(struct ieee80211_device *ieee, struct sk_buff *skb, u8 *src)

1832

{

1833

u8 *tag;

1834

u8 *skbend;

1835

u8 *ssid=NULL;

1836

u8 ssidlen = 0;

1837

1838

struct ieee80211_hdr_3addr *header =

1839

(struct ieee80211_hdr_3addr *) skb->data;

1840

1841

if (skb->len < sizeof (struct ieee80211_hdr_3addr ))

1842

return -1; /* corrupted */

1843

1844

memcpy(src,header->addr2, ETH_ALEN);

1845

1846

skbend = (u8*)skb->data + skb->len;

1847

1848

tag = skb->data + sizeof (struct ieee80211_hdr_3addr );

1849

1850

while (tag+1 < skbend){

1851

if (*tag == 0){

1852

ssid = tag+2;

1853

ssidlen = *(tag+1);

1854

break;

1855

}

1856

tag++; /* point to the len field */

1857

tag = tag + *(tag); /* point to the last data byte of the tag */

1858

tag++; /* point to the next tag */

1859

}

1860

1861

//IEEE80211DMESG("Card MAC address is "MACSTR, MAC2STR(src));

1862

if (ssidlen == 0) return 1;

1863

1864

if (!ssid) return 1; /* ssid not found in tagged param */

1865

return (!strncmp(ssid, ieee->current_network.ssid, ssidlen));

1866

1867

}

1868

1869

int assoc_rq_parse(struct sk_buff *skb,u8* dest)

1870

{

1871

struct ieee80211_assoc_request_frame *a;

1872

1873

if (skb->len < (sizeof(struct ieee80211_assoc_request_frame) -

1874

sizeof(struct ieee80211_info_element))) {

1875

1876

IEEE80211_DEBUG_MGMT("invalid len in auth request:%d \n", skb->len);

1877

return -1;

1878

}

1879

1880

a = (struct ieee80211_assoc_request_frame*) skb->data;

1881

1882

memcpy(dest,a->header.addr2,ETH_ALEN);

1883

1884

return 0;

1885

}

1886

1887

static inline u16 assoc_parse(struct ieee80211_device *ieee, struct sk_buff *skb, int *aid)

1888

{

1889

struct ieee80211_assoc_response_frame *response_head;

1890

u16 status_code;

1891

1892

if (skb->len < sizeof(struct ieee80211_assoc_response_frame)){

1893

IEEE80211_DEBUG_MGMT("invalid len in auth resp: %d\n", skb->len);

1894

return 0xcafe;

1895

}

1896

1897

response_head = (struct ieee80211_assoc_response_frame*) skb->data;

1898

*aid = le16_to_cpu(response_head->aid) & 0x3fff;

1899

1900

status_code = le16_to_cpu(response_head->status);

1901

if((status_code==WLAN_STATUS_ASSOC_DENIED_RATES || \

1902

status_code==WLAN_STATUS_CAPS_UNSUPPORTED)&&

1903

((ieee->mode == IEEE_G) &&

1904

(ieee->current_network.mode == IEEE_N_24G) &&

1905

(ieee->AsocRetryCount++ < (RT_ASOC_RETRY_LIMIT-1)))) {

1906

ieee->pHTInfo->IOTAction |= HT_IOT_ACT_PURE_N_MODE;

1907

}else {

1908

ieee->AsocRetryCount = 0;

1909

}

1910

1911

return le16_to_cpu(response_head->status);

1912

}

1913

1914

static inline void

1915

ieee80211_rx_probe_rq(struct ieee80211_device *ieee, struct sk_buff *skb)

1916

{

1917

u8 dest[ETH_ALEN];

1918

1919

//IEEE80211DMESG("Rx probe");

1920

ieee->softmac_stats.rx_probe_rq++;

1921

//DMESG("Dest is "MACSTR, MAC2STR(dest));

1922

if (probe_rq_parse(ieee, skb, dest)){

1923

//IEEE80211DMESG("Was for me!");

1924

ieee->softmac_stats.tx_probe_rs++;

1925

ieee80211_resp_to_probe(ieee, dest);

1926

}

1927

}

1928

1929

static inline void

1930

ieee80211_rx_auth_rq(struct ieee80211_device *ieee, struct sk_buff *skb)

1931

{

1932

u8 dest[ETH_ALEN];

1933

int status;

1934

//IEEE80211DMESG("Rx probe");

1935

ieee->softmac_stats.rx_auth_rq++;

1936

1937

status = auth_rq_parse(skb, dest);

1938

if (status != -1) {

1939

ieee80211_resp_to_auth(ieee, status, dest);

1940

}

1941

//DMESG("Dest is "MACSTR, MAC2STR(dest));

1942

1943

}

1944

1945

static inline void

1946

ieee80211_rx_assoc_rq(struct ieee80211_device *ieee, struct sk_buff *skb)

1947

{

1948

1949

u8 dest[ETH_ALEN];

1950

//unsigned long flags;

1951

1952

ieee->softmac_stats.rx_ass_rq++;

1953

if (assoc_rq_parse(skb,dest) != -1){

1954

ieee80211_resp_to_assoc_rq(ieee, dest);

1955

}

1956

1957

printk(KERN_INFO"New client associated: %pM\n", dest);

1958

//FIXME

1959

#if 0

1960

spin_lock_irqsave(&ieee->lock,flags);

1961

add_associate(ieee,dest);

1962

spin_unlock_irqrestore(&ieee->lock,flags);

1963

#endif

1964

}

1965

1966

1967

1968

void ieee80211_sta_ps_send_null_frame(struct ieee80211_device *ieee, short pwr)

1969

{

1970

1971

struct sk_buff *buf = ieee80211_null_func(ieee, pwr);

1972

1973

if (buf)

1974

softmac_ps_mgmt_xmit(buf, ieee);

1975

1976

}

1977

1978

void ieee80211_sta_ps_send_pspoll_frame(struct ieee80211_device *ieee)

1979

{

1980

1981

struct sk_buff *buf = ieee80211_pspoll_func(ieee);

1982

1983

if (buf)

1984

softmac_ps_mgmt_xmit(buf, ieee);

1985

1986

}

1987

1988

short ieee80211_sta_ps_sleep(struct ieee80211_device *ieee, u32 *time_h, u32 *time_l)

1989

{

1990

int timeout = ieee->ps_timeout;

1991

u8 dtim;

1992

PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(ieee->PowerSaveControl));

1993

1994

if(ieee->LPSDelayCnt)

1995

{

1996

//printk("===============>Delay enter LPS for DHCP and ARP packets...\n");

1997

ieee->LPSDelayCnt --;

1998

return 0;

1999

}

2000

2001

dtim = ieee->current_network.dtim_data;

2002

// printk("%s():DTIM:%d\n",__FUNCTION__,dtim);

2003

if(!(dtim & IEEE80211_DTIM_VALID))

2004

return 0;

2005

timeout = ieee->current_network.beacon_interval; //should we use ps_timeout value or beacon_interval

2006

//printk("VALID\n");

2007

ieee->current_network.dtim_data = IEEE80211_DTIM_INVALID;

2008

/* there's no need to nofity AP that I find you buffered with broadcast packet */

2009

if(dtim & (IEEE80211_DTIM_UCAST & ieee->ps))

2010

return 2;

2011

2012

if(!time_after(jiffies, ieee->dev->trans_start + MSECS(timeout))){

2013

// printk("%s():111Oh Oh ,it is not time out return 0\n",__FUNCTION__);

2014

return 0;

2015

}

2016

if(!time_after(jiffies, ieee->last_rx_ps_time + MSECS(timeout))){

2017

// printk("%s():222Oh Oh ,it is not time out return 0\n",__FUNCTION__);

2018

return 0;

2019

}

2020

if((ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE ) &&

2021

(ieee->mgmt_queue_tail != ieee->mgmt_queue_head))

2022

return 0;

2023

2024

if(time_l){

2025

if(ieee->bAwakePktSent == true) {

2026

pPSC->LPSAwakeIntvl = 1;//tx wake one beacon

2027

} else {

2028

u8 MaxPeriod = 1;

2029

2030

if(pPSC->LPSAwakeIntvl == 0)

2031

pPSC->LPSAwakeIntvl = 1;

2032

//pNdisCommon->RegLPSMaxIntvl /// 0x0 - eFastPs, 0xFF -DTIM, 0xNN - 0xNN * BeaconIntvl

2033

if(pPSC->RegMaxLPSAwakeIntvl == 0) // Default (0x0 - eFastPs, 0xFF -DTIM, 0xNN - 0xNN * BeaconIntvl)

2034

MaxPeriod = 1; // 1 Beacon interval

2035

else if(pPSC->RegMaxLPSAwakeIntvl == 0xFF) // DTIM

2036

MaxPeriod = ieee->current_network.dtim_period;

2037

else

2038

MaxPeriod = pPSC->RegMaxLPSAwakeIntvl;

2039

pPSC->LPSAwakeIntvl = (pPSC->LPSAwakeIntvl >= MaxPeriod) ? MaxPeriod : (pPSC->LPSAwakeIntvl + 1);

2040

}

2041

{

2042

u8 LPSAwakeIntvl_tmp = 0;

2043

u8 period = ieee->current_network.dtim_period;

2044

u8 count = ieee->current_network.tim.tim_count;

2045

if(count == 0 ) {

2046

if(pPSC->LPSAwakeIntvl > period)

2047

LPSAwakeIntvl_tmp = period + (pPSC->LPSAwakeIntvl - period) -((pPSC->LPSAwakeIntvl-period)%period);

2048

else

2049

LPSAwakeIntvl_tmp = pPSC->LPSAwakeIntvl;

2050

2051

} else {

2052

if(pPSC->LPSAwakeIntvl > ieee->current_network.tim.tim_count)

2053

LPSAwakeIntvl_tmp = count + (pPSC->LPSAwakeIntvl - count) -((pPSC->LPSAwakeIntvl-count)%period);

2054

else

2055

LPSAwakeIntvl_tmp = pPSC->LPSAwakeIntvl;//ieee->current_network.tim.tim_count;//pPSC->LPSAwakeIntvl;

2056

}

2057

//printk("=========>%s()assoc_id:%d(%#x),bAwakePktSent:%d,DTIM:%d, sleep interval:%d, LPSAwakeIntvl_tmp:%d, count:%d\n",__func__,ieee->assoc_id,cpu_to_le16(ieee->assoc_id),ieee->bAwakePktSent,ieee->current_network.dtim_period,pPSC->LPSAwakeIntvl,LPSAwakeIntvl_tmp,count);

2058

2059

*time_l = ieee->current_network.last_dtim_sta_time[0]

2060

+ MSECS(ieee->current_network.beacon_interval * LPSAwakeIntvl_tmp);

2061

// * ieee->current_network.dtim_period) * 1000;

2062

}

2063

}

2064

2065

if(time_h){

2066

*time_h = ieee->current_network.last_dtim_sta_time[1];

2067

if(time_l && *time_l < ieee->current_network.last_dtim_sta_time[0])

2068

*time_h += 1;

2069

}

2070

2071

return 1;

2072

2073

2074

}

2075

2076

inline void ieee80211_sta_ps(struct ieee80211_device *ieee)

2077

{

2078

2079

u32 th,tl;

2080

short sleep;

2081

2082

unsigned long flags,flags2;

2083

2084

spin_lock_irqsave(&ieee->lock, flags);

2085

2086

if((ieee->ps == IEEE80211_PS_DISABLED ||

2087

ieee->iw_mode != IW_MODE_INFRA ||

2088

ieee->state != IEEE80211_LINKED)){

2089

2090

// #warning CHECK_LOCK_HERE

2091

printk("=====>%s(): no need to ps,wake up!! ieee->ps is %d,ieee->iw_mode is %d,ieee->state is %d\n",

2092

__FUNCTION__,ieee->ps,ieee->iw_mode,ieee->state);

2093

spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);

2094

2095

ieee80211_sta_wakeup(ieee, 1);

2096

2097

spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);

2098

}

2099

2100

sleep = ieee80211_sta_ps_sleep(ieee,&th, &tl);

2101

/* 2 wake, 1 sleep, 0 do nothing */

2102

if(sleep == 0)//it is not time out or dtim is not valid

2103

{

2104

//printk("===========>sleep is 0,do nothing\n");

2105

goto out;

2106

}

2107

if(sleep == 1){

2108

//printk("===========>sleep is 1,to sleep\n");

2109

if(ieee->sta_sleep == 1){

2110

//printk("%s(1): sta_sleep = 1, sleep again ++++++++++ \n", __func__);

2111

ieee->enter_sleep_state(ieee->dev,th,tl);

2112

}

2113

2114

else if(ieee->sta_sleep == 0){

2115

// printk("send null 1\n");

2116

spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);

2117

2118

if(ieee->ps_is_queue_empty(ieee->dev)){

2119

ieee->sta_sleep = 2;

2120

ieee->ack_tx_to_ieee = 1;

2121

//printk("%s(2): sta_sleep = 0, notify AP we will sleeped ++++++++++ SendNullFunctionData\n", __func__);

2122

ieee80211_sta_ps_send_null_frame(ieee,1);

2123

ieee->ps_th = th;

2124

ieee->ps_tl = tl;

2125

}

2126

spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);

2127

2128

}

2129

2130

ieee->bAwakePktSent = false;//after null to power save we set it to false. not listen every beacon.

2131

2132

}else if(sleep == 2){

2133

//printk("==========>sleep is 2,to wakeup\n");

2134

spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);

2135

2136

//printk("%s(3): pkt buffered in ap will awake ++++++++++ ieee80211_sta_wakeup\n", __func__);

2137

ieee80211_sta_wakeup(ieee,1);

2138

2139

spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);

2140

}

2141

2142

out:

2143

spin_unlock_irqrestore(&ieee->lock, flags);

2144

2145

}

2146

2147

void ieee80211_sta_wakeup(struct ieee80211_device *ieee, short nl)

2148

{

2149

if(ieee->sta_sleep == 0){

2150

if(nl){

2151

if(ieee->pHTInfo->IOTAction & HT_IOT_ACT_NULL_DATA_POWER_SAVING)

2152

{

2153

//printk("%s(1): notify AP we are awaked ++++++++++ SendNullFunctionData\n", __func__);

2154

//printk("Warning: driver is probably failing to report TX ps error\n");

2155

ieee->ack_tx_to_ieee = 1;

2156

ieee80211_sta_ps_send_null_frame(ieee, 0);

2157

}

2158

else

2159

{

2160

ieee->ack_tx_to_ieee = 1;

2161

//printk("%s(2): notify AP we are awaked ++++++++++ Send PS-Poll\n", __func__);

2162

ieee80211_sta_ps_send_pspoll_frame(ieee);

2163

}

2164

}

2165

return;

2166

2167

}

2168

2169

if(ieee->sta_sleep == 1)

2170

ieee->sta_wake_up(ieee->dev);

2171

if(nl){

2172

2173

if(ieee->pHTInfo->IOTAction & HT_IOT_ACT_NULL_DATA_POWER_SAVING)

2174

{

2175

//printk("%s(3): notify AP we are awaked ++++++++++ SendNullFunctionData\n", __func__);

2176

//printk("Warning: driver is probably failing to report TX ps error\n");

2177

ieee->ack_tx_to_ieee = 1;

2178

ieee80211_sta_ps_send_null_frame(ieee, 0);

2179

}

2180

else

2181

{

2182

ieee->ack_tx_to_ieee = 1;

2183

ieee->polling = true;

2184

//printk("%s(4): notify AP we are awaked ++++++++++ Send PS-Poll\n", __func__);

2185

//ieee80211_sta_ps_send_null_frame(ieee, 0);

2186

ieee80211_sta_ps_send_pspoll_frame(ieee);

2187

}

2188

2189

} else {

2190

ieee->sta_sleep = 0;

2191

ieee->polling = false;

2192

}

2193

}

2194

2195

void ieee80211_ps_tx_ack(struct ieee80211_device *ieee, short success)

2196

{

2197

unsigned long flags,flags2;

2198

2199

spin_lock_irqsave(&ieee->lock, flags);

2200

2201

if(ieee->sta_sleep == 2){

2202

/* Null frame with PS bit set */

2203

if(success){

2204

ieee->sta_sleep = 1;

2205

//printk("notify AP we will sleep and send null ok, so sleep now++++++++++ enter_sleep_state\n");

2206

ieee->enter_sleep_state(ieee->dev,ieee->ps_th,ieee->ps_tl);

2207

}

2208

} else {/* 21112005 - tx again null without PS bit if lost */

2209

2210

if((ieee->sta_sleep == 0) && !success){

2211

spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);

2212

//ieee80211_sta_ps_send_null_frame(ieee, 0);

2213

if(ieee->pHTInfo->IOTAction & HT_IOT_ACT_NULL_DATA_POWER_SAVING)

2214

{

2215

//printk("notify AP we will sleep but send bull failed, so resend++++++++++ SendNullFunctionData\n");

2216

ieee80211_sta_ps_send_null_frame(ieee, 0);

2217

}

2218

else

2219

{

2220

//printk("notify AP we are awaked but send pspoll failed, so resend++++++++++ Send PS-Poll\n");

2221

ieee80211_sta_ps_send_pspoll_frame(ieee);

2222

}

2223

spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);

2224

}

2225

}

2226

spin_unlock_irqrestore(&ieee->lock, flags);

2227

}

2228

2229

void ieee80211_process_action(struct ieee80211_device* ieee, struct sk_buff* skb)

2230

{

2231

struct ieee80211_hdr* header = (struct ieee80211_hdr*)skb->data;

2232

u8* act = ieee80211_get_payload(header);

2233

u8 tmp = 0;

2234

// IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA|IEEE80211_DL_BA, skb->data, skb->len);

2235

if (act == NULL)

2236

{

2237

IEEE80211_DEBUG(IEEE80211_DL_ERR, "error to get payload of action frame\n");

2238

return;

2239

}

2240

tmp = *act;

2241

act ++;

2242

switch (tmp)

2243

{

2244

case ACT_CAT_BA:

2245

if (*act == ACT_ADDBAREQ)

2246

ieee80211_rx_ADDBAReq(ieee, skb);

2247

else if (*act == ACT_ADDBARSP)

2248

ieee80211_rx_ADDBARsp(ieee, skb);

2249

else if (*act == ACT_DELBA)

2250

ieee80211_rx_DELBA(ieee, skb);

2251

break;

2252

default:

2253

// if (net_ratelimit())

2254

// IEEE80211_DEBUG(IEEE80211_DL_BA, "unknown action frame(%d)\n", tmp);

2255

break;

2256

}

2257

return;

2258

2259

}

2260

inline int

2261

ieee80211_rx_frame_softmac(struct ieee80211_device *ieee, struct sk_buff *skb,

2262

struct ieee80211_rx_stats *rx_stats, u16 type,

2263

u16 stype)

2264

{

2265

struct ieee80211_hdr_3addr *header = (struct ieee80211_hdr_3addr *) skb->data;

2266

u16 errcode;

2267

u8* challenge;

2268

int chlen=0;

2269

int aid;

2270

struct ieee80211_assoc_response_frame *assoc_resp;

2271

// struct ieee80211_info_element *info_element;

2272

bool bSupportNmode = true, bHalfSupportNmode = false; //default support N mode, disable halfNmode

2273

2274

if(!ieee->proto_started)

2275

return 0;

2276

#if 0

2277

printk("%d, %d, %d, %d\n", ieee->sta_sleep, ieee->ps, ieee->iw_mode, ieee->state);

2278

if(ieee->sta_sleep || (ieee->ps != IEEE80211_PS_DISABLED &&

2279

ieee->iw_mode == IW_MODE_INFRA &&

2280

ieee->state == IEEE80211_LINKED))

2281

2282

tasklet_schedule(&ieee->ps_task);

2283

2284

if(WLAN_FC_GET_STYPE(header->frame_ctl) != IEEE80211_STYPE_PROBE_RESP &&

2285

WLAN_FC_GET_STYPE(header->frame_ctl) != IEEE80211_STYPE_BEACON)

2286

ieee->last_rx_ps_time = jiffies;

2287

#endif

2288

2289

switch (WLAN_FC_GET_STYPE(header->frame_ctl)) {

2290

2291

case IEEE80211_STYPE_ASSOC_RESP:

2292

case IEEE80211_STYPE_REASSOC_RESP:

2293

2294

IEEE80211_DEBUG_MGMT("received [RE]ASSOCIATION RESPONSE (%d)\n",

2295

WLAN_FC_GET_STYPE(header->frame_ctl));

2296

if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&

2297

ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATED &&

2298

ieee->iw_mode == IW_MODE_INFRA){

2299

struct ieee80211_network network_resp;

2300

struct ieee80211_network *network = &network_resp;

2301

2302

if (0 == (errcode=assoc_parse(ieee,skb, &aid))){

2303

ieee->state=IEEE80211_LINKED;

2304

ieee->assoc_id = aid;

2305

ieee->softmac_stats.rx_ass_ok++;

2306

/* station support qos */

2307

/* Let the register setting defaultly with Legacy station */

2308

if(ieee->qos_support) {

2309

assoc_resp = (struct ieee80211_assoc_response_frame*)skb->data;

2310

memset(network, 0, sizeof(*network));

2311

if (ieee80211_parse_info_param(ieee,assoc_resp->info_element,\

2312

rx_stats->len - sizeof(*assoc_resp),\

2313

network,rx_stats)){

2314

return 1;

2315

}

2316

else

2317

{ //filling the PeerHTCap. //maybe not neccesary as we can get its info from current_network.

2318

memcpy(ieee->pHTInfo->PeerHTCapBuf, network->bssht.bdHTCapBuf, network->bssht.bdHTCapLen);

2319

memcpy(ieee->pHTInfo->PeerHTInfoBuf, network->bssht.bdHTInfoBuf, network->bssht.bdHTInfoLen);

2320

}

2321

if (ieee->handle_assoc_response != NULL)

2322

ieee->handle_assoc_response(ieee->dev, (struct ieee80211_assoc_response_frame*)header, network);

2323

}

2324

ieee80211_associate_complete(ieee);

2325

} else {

2326

/* aid could not been allocated */

2327

ieee->softmac_stats.rx_ass_err++;

2328

printk(

2329

"Association response status code 0x%x\n",

2330

errcode);

2331

IEEE80211_DEBUG_MGMT(

2332

"Association response status code 0x%x\n",

2333

errcode);

2334

if(ieee->AsocRetryCount < RT_ASOC_RETRY_LIMIT) {

2335

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

2336

queue_work(ieee->wq, &ieee->associate_procedure_wq);

2337

#else

2338

schedule_task(&ieee->associate_procedure_wq);

2339

#endif

2340

} else {

2341

ieee80211_associate_abort(ieee);

2342

}

2343

}

2344

}

2345

break;

2346

2347

case IEEE80211_STYPE_ASSOC_REQ:

2348

case IEEE80211_STYPE_REASSOC_REQ:

2349

2350

if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&

2351

ieee->iw_mode == IW_MODE_MASTER)

2352

2353

ieee80211_rx_assoc_rq(ieee, skb);

2354

break;

2355

2356

case IEEE80211_STYPE_AUTH:

2357

2358

if (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE){

2359

if (ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATING &&

2360

ieee->iw_mode == IW_MODE_INFRA){

2361

2362

IEEE80211_DEBUG_MGMT("Received authentication response");

2363

2364

if (0 == (errcode=auth_parse(skb, &challenge, &chlen))){

2365

if(ieee->open_wep || !challenge){

2366

ieee->state = IEEE80211_ASSOCIATING_AUTHENTICATED;

2367

ieee->softmac_stats.rx_auth_rs_ok++;

2368

if(!(ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE))

2369

{

2370

if (!ieee->GetNmodeSupportBySecCfg(ieee->dev))

2371

{

2372

// WEP or TKIP encryption

2373

if(IsHTHalfNmodeAPs(ieee))

2374

{

2375

bSupportNmode = true;

2376

bHalfSupportNmode = true;

2377

}

2378

else

2379

{

2380

bSupportNmode = false;

2381

bHalfSupportNmode = false;

2382

}

2383

printk("==========>to link with AP using SEC(%d, %d)\n", bSupportNmode, bHalfSupportNmode);

2384

}

2385

}

2386

/* Dummy wirless mode setting to avoid encryption issue */

2387

if(bSupportNmode) {

2388

//N mode setting

2389

ieee->SetWirelessMode(ieee->dev, \

2390

ieee->current_network.mode);

2391

}else{

2392

//b/g mode setting

2393

/*TODO*/

2394

ieee->SetWirelessMode(ieee->dev, IEEE_G);

2395

}

2396

2397

if (ieee->current_network.mode == IEEE_N_24G && bHalfSupportNmode == true)

2398

{

2399

printk("===============>entern half N mode\n");

2400

ieee->bHalfWirelessN24GMode = true;

2401

}

2402

else

2403

ieee->bHalfWirelessN24GMode = false;

2404

2405

ieee80211_associate_step2(ieee);

2406

}else{

2407

ieee80211_rtl_auth_challenge(ieee, challenge, chlen);

2408

}

2409

}else{

2410

ieee->softmac_stats.rx_auth_rs_err++;

2411

IEEE80211_DEBUG_MGMT("Authentication respose status code 0x%x",errcode);

2412

2413

printk("Authentication respose status code 0x%x",errcode);

2414

ieee80211_associate_abort(ieee);

2415

}

2416

2417

}else if (ieee->iw_mode == IW_MODE_MASTER){

2418

ieee80211_rx_auth_rq(ieee, skb);

2419

}

2420

}

2421

break;

2422

2423

case IEEE80211_STYPE_PROBE_REQ:

2424

2425

if ((ieee->softmac_features & IEEE_SOFTMAC_PROBERS) &&

2426

((ieee->iw_mode == IW_MODE_ADHOC ||

2427

ieee->iw_mode == IW_MODE_MASTER) &&

2428

ieee->state == IEEE80211_LINKED)){

2429

ieee80211_rx_probe_rq(ieee, skb);

2430

}

2431

break;

2432

2433

case IEEE80211_STYPE_DISASSOC:

2434

case IEEE80211_STYPE_DEAUTH:

2435

/* FIXME for now repeat all the association procedure

2436

* both for disassociation and deauthentication

2437

2438

if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&

2439

ieee->state == IEEE80211_LINKED &&

2440

ieee->iw_mode == IW_MODE_INFRA){

2441

2442

ieee->state = IEEE80211_ASSOCIATING;

2443

ieee->softmac_stats.reassoc++;

2444

ieee->is_roaming = true;

2445

ieee80211_disassociate(ieee);

2446

// notify_wx_assoc_event(ieee);

2447

//HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);

2448

RemovePeerTS(ieee, header->addr2);

2449

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

2450

queue_work(ieee->wq, &ieee->associate_procedure_wq);

2451

#else

2452

schedule_task(&ieee->associate_procedure_wq);

2453

#endif

2454

}

2455

break;

2456

case IEEE80211_STYPE_MANAGE_ACT:

2457

ieee80211_process_action(ieee,skb);

2458

break;

2459

default:

2460

return -1;

2461

break;

2462

}

2463

2464

//dev_kfree_skb_any(skb);

2465

return 0;

2466

}

2467

2468

/* following are for a simplier TX queue management.

2469

* Instead of using netif_[stop/wake]_queue the driver

2470

* will uses these two function (plus a reset one), that

2471

* will internally uses the kernel netif_* and takes

2472

* care of the ieee802.11 fragmentation.

2473

* So the driver receives a fragment per time and might

2474

* call the stop function when it want without take care

2475

* to have enough room to TX an entire packet.

2476

* This might be useful if each fragment need it's own

2477

* descriptor, thus just keep a total free memory > than

2478

* the max fragmentation threshold is not enough.. If the

2479

* ieee802.11 stack passed a TXB struct then you needed

2480

* to keep N free descriptors where

2481

* N = MAX_PACKET_SIZE / MIN_FRAG_TRESHOLD

2482

* In this way you need just one and the 802.11 stack

2483

* will take care of buffering fragments and pass them to

2484

* to the driver later, when it wakes the queue.

2485

2486

void ieee80211_softmac_xmit(struct ieee80211_txb *txb, struct ieee80211_device *ieee)

2487

{

2488

2489

unsigned int queue_index = txb->queue_index;

2490

unsigned long flags;

2491

int i;

2492

cb_desc *tcb_desc = NULL;

2493

2494

spin_lock_irqsave(&ieee->lock,flags);

2495

2496

/* called with 2nd parm 0, no tx mgmt lock required */

2497

ieee80211_sta_wakeup(ieee,0);

2498

2499

/* update the tx status */

2500

// ieee->stats.tx_bytes += txb->payload_size;

2501

// ieee->stats.tx_packets++;

2502

tcb_desc = (cb_desc *)(txb->fragments[0]->cb + MAX_DEV_ADDR_SIZE);

2503

if(tcb_desc->bMulticast) {

2504

ieee->stats.multicast++;

2505

}

2506

#if 1

2507

/* if xmit available, just xmit it immediately, else just insert it to the wait queue */

2508

for(i = 0; i < txb->nr_frags; i++) {

2509

#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE

2510

if ((skb_queue_len(&ieee->skb_drv_aggQ[queue_index]) != 0) ||

2511

#else

2512

if ((skb_queue_len(&ieee->skb_waitQ[queue_index]) != 0) ||

2513

#endif

2514

(!ieee->check_nic_enough_desc(ieee->dev,queue_index))||\

2515

(ieee->queue_stop)) {

2516

/* insert the skb packet to the wait queue */

2517

/* as for the completion function, it does not need

2518

* to check it any more.

2519

* */

2520

//printk("error:no descriptor left@queue_index %d\n", queue_index);

2521

//ieee80211_rtl_stop_queue(ieee);

2522

#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE

2523

skb_queue_tail(&ieee->skb_drv_aggQ[queue_index], txb->fragments[i]);

2524

#else

2525

skb_queue_tail(&ieee->skb_waitQ[queue_index], txb->fragments[i]);

2526

#endif

2527

}else{

2528

ieee->softmac_data_hard_start_xmit(

2529

txb->fragments[i],

2530

ieee->dev,ieee->rate);

2531

//ieee->stats.tx_packets++;

2532

//ieee->stats.tx_bytes += txb->fragments[i]->len;

2533

//ieee->dev->trans_start = jiffies;

2534

}

2535

}

2536

#endif

2537

ieee80211_txb_free(txb);

2538

2539

//exit:

2540

spin_unlock_irqrestore(&ieee->lock,flags);

2541

2542

}

2543

2544

/* called with ieee->lock acquired */

2545

void ieee80211_resume_tx(struct ieee80211_device *ieee)

2546

{

2547

int i;

2548

for(i = ieee->tx_pending.frag; i < ieee->tx_pending.txb->nr_frags; i++) {

2549

2550

if (ieee->queue_stop){

2551

ieee->tx_pending.frag = i;

2552

return;

2553

}else{

2554

2555

ieee->softmac_data_hard_start_xmit(

2556

ieee->tx_pending.txb->fragments[i],

2557

ieee->dev,ieee->rate);

2558

//(i+1)<ieee->tx_pending.txb->nr_frags);

2559

ieee->stats.tx_packets++;

2560

// ieee->dev->trans_start = jiffies;

2561

}

2562

}

2563

2564

2565

ieee80211_txb_free(ieee->tx_pending.txb);

2566

ieee->tx_pending.txb = NULL;

2567

}

2568

2569

2570

void ieee80211_reset_queue(struct ieee80211_device *ieee)

2571

{

2572

unsigned long flags;

2573

2574

spin_lock_irqsave(&ieee->lock,flags);

2575

init_mgmt_queue(ieee);

2576

if (ieee->tx_pending.txb){

2577

ieee80211_txb_free(ieee->tx_pending.txb);

2578

ieee->tx_pending.txb = NULL;

2579

}

2580

ieee->queue_stop = 0;

2581

spin_unlock_irqrestore(&ieee->lock,flags);

2582

2583

}

2584

2585

void ieee80211_rtl_wake_queue(struct ieee80211_device *ieee)

2586

{

2587

2588

unsigned long flags;

2589

struct sk_buff *skb;

2590

struct ieee80211_hdr_3addr *header;

2591

2592

spin_lock_irqsave(&ieee->lock,flags);

2593

if (! ieee->queue_stop) goto exit;

2594

2595

ieee->queue_stop = 0;

2596

2597

if(ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE){

2598

while (!ieee->queue_stop && (skb = dequeue_mgmt(ieee))){

2599

2600

header = (struct ieee80211_hdr_3addr *) skb->data;

2601

2602

header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4);

2603

2604

if (ieee->seq_ctrl[0] == 0xFFF)

2605

ieee->seq_ctrl[0] = 0;

2606

else

2607

ieee->seq_ctrl[0]++;

2608

2609

ieee->softmac_data_hard_start_xmit(skb,ieee->dev,ieee->basic_rate);

2610

//dev_kfree_skb_any(skb);//edit by thomas

2611

}

2612

}

2613

if (!ieee->queue_stop && ieee->tx_pending.txb)

2614

ieee80211_resume_tx(ieee);

2615

2616

if (!ieee->queue_stop && netif_queue_stopped(ieee->dev)){

2617

ieee->softmac_stats.swtxawake++;

2618

netif_wake_queue(ieee->dev);

2619

}

2620

2621

exit :

2622

spin_unlock_irqrestore(&ieee->lock,flags);

2623

}

2624

2625

2626

void ieee80211_rtl_stop_queue(struct ieee80211_device *ieee)

2627

{

2628

//unsigned long flags;

2629

//spin_lock_irqsave(&ieee->lock,flags);

2630

2631

if (! netif_queue_stopped(ieee->dev)){

2632

netif_stop_queue(ieee->dev);

2633

ieee->softmac_stats.swtxstop++;

2634

}

2635

ieee->queue_stop = 1;

2636

//spin_unlock_irqrestore(&ieee->lock,flags);

2637

2638

}

2639

2640

2641

inline void ieee80211_randomize_cell(struct ieee80211_device *ieee)

2642

{

2643

2644

get_random_bytes(ieee->current_network.bssid, ETH_ALEN);

2645

2646

/* an IBSS cell address must have the two less significant

2647

* bits of the first byte = 2

2648

2649

ieee->current_network.bssid[0] &= ~0x01;

2650

ieee->current_network.bssid[0] |= 0x02;

2651

}

2652

2653

/* called in user context only */

2654

void ieee80211_start_master_bss(struct ieee80211_device *ieee)

2655

{

2656

ieee->assoc_id = 1;

2657

2658

if (ieee->current_network.ssid_len == 0){

2659

strncpy(ieee->current_network.ssid,

2660

IEEE80211_DEFAULT_TX_ESSID,

2661

IW_ESSID_MAX_SIZE);

2662

2663

ieee->current_network.ssid_len = strlen(IEEE80211_DEFAULT_TX_ESSID);

2664

ieee->ssid_set = 1;

2665

}

2666

2667

memcpy(ieee->current_network.bssid, ieee->dev->dev_addr, ETH_ALEN);

2668

2669

ieee->set_chan(ieee->dev, ieee->current_network.channel);

2670

ieee->state = IEEE80211_LINKED;

2671

ieee->link_change(ieee->dev);

2672

notify_wx_assoc_event(ieee);

2673

2674

if (ieee->data_hard_resume)

2675

ieee->data_hard_resume(ieee->dev);

2676

2677

netif_carrier_on(ieee->dev);

2678

}

2679

2680

void ieee80211_start_monitor_mode(struct ieee80211_device *ieee)

2681

{

2682

if(ieee->raw_tx){

2683

2684

if (ieee->data_hard_resume)

2685

ieee->data_hard_resume(ieee->dev);

2686

2687

netif_carrier_on(ieee->dev);

2688

}

2689

}

2690

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))

2691

void ieee80211_start_ibss_wq(struct work_struct *work)

2692

{

2693

2694

struct delayed_work *dwork = container_of(work, struct delayed_work, work);

2695

struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, start_ibss_wq);

2696

#else

2697

void ieee80211_start_ibss_wq(struct ieee80211_device *ieee)

2698

{

2699

#endif

2700

/* iwconfig mode ad-hoc will schedule this and return

2701

* on the other hand this will block further iwconfig SET

2702

* operations because of the wx_sem hold.

2703

* Anyway some most set operations set a flag to speed-up

2704

* (abort) this wq (when syncro scanning) before sleeping

2705

* on the semaphore

2706

2707

if(!ieee->proto_started){

2708

printk("==========oh driver down return\n");

2709

return;

2710

}

2711

down(&ieee->wx_sem);

2712

2713

if (ieee->current_network.ssid_len == 0){

2714

strcpy(ieee->current_network.ssid,IEEE80211_DEFAULT_TX_ESSID);

2715

ieee->current_network.ssid_len = strlen(IEEE80211_DEFAULT_TX_ESSID);

2716

ieee->ssid_set = 1;

2717

}

2718

2719

ieee->state = IEEE80211_NOLINK;

2720

/* check if we have this cell in our network list */

2721

ieee80211_softmac_check_all_nets(ieee);

2722

2723

2724

#ifdef ENABLE_DOT11D //if creating an ad-hoc, set its channel to 10 temporarily--this is the requirement for ASUS, not 11D, so disable 11d.

2725

// if((IS_DOT11D_ENABLE(ieee)) && (ieee->state == IEEE80211_NOLINK))

2726

if (ieee->state == IEEE80211_NOLINK)

2727

ieee->current_network.channel = 6;

2728

#endif

2729

/* if not then the state is not linked. Maybe the user swithced to

2730

* ad-hoc mode just after being in monitor mode, or just after

2731

* being very few time in managed mode (so the card have had no

2732

* time to scan all the chans..) or we have just run up the iface

2733

* after setting ad-hoc mode. So we have to give another try..

2734

* Here, in ibss mode, should be safe to do this without extra care

2735

* (in bss mode we had to make sure no-one tryed to associate when

2736

* we had just checked the ieee->state and we was going to start the

2737

* scan) beacause in ibss mode the ieee80211_new_net function, when

2738

* finds a good net, just set the ieee->state to IEEE80211_LINKED,

2739

* so, at worst, we waste a bit of time to initiate an unneeded syncro

2740

* scan, that will stop at the first round because it sees the state

2741

* associated.

2742

2743

if (ieee->state == IEEE80211_NOLINK)

2744

ieee80211_start_scan_syncro(ieee);

2745

2746

/* the network definitively is not here.. create a new cell */

2747

if (ieee->state == IEEE80211_NOLINK){

2748

printk("creating new IBSS cell\n");

2749

if(!ieee->wap_set)

2750

ieee80211_randomize_cell(ieee);

2751

2752

if(ieee->modulation & IEEE80211_CCK_MODULATION){

2753

2754

ieee->current_network.rates_len = 4;

2755

2756

ieee->current_network.rates[0] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;

2757

ieee->current_network.rates[1] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;

2758

ieee->current_network.rates[2] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_5MB;

2759

ieee->current_network.rates[3] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_11MB;

2760

2761

}else

2762

ieee->current_network.rates_len = 0;

2763

2764

if(ieee->modulation & IEEE80211_OFDM_MODULATION){

2765

ieee->current_network.rates_ex_len = 8;

2766

2767

ieee->current_network.rates_ex[0] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_6MB;

2768

ieee->current_network.rates_ex[1] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_9MB;

2769

ieee->current_network.rates_ex[2] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_12MB;

2770

ieee->current_network.rates_ex[3] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_18MB;

2771

ieee->current_network.rates_ex[4] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_24MB;

2772

ieee->current_network.rates_ex[5] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_36MB;

2773

ieee->current_network.rates_ex[6] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_48MB;

2774

ieee->current_network.rates_ex[7] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_54MB;

2775

2776

ieee->rate = 108;

2777

}else{

2778

ieee->current_network.rates_ex_len = 0;

2779

ieee->rate = 22;

2780

}

2781

2782

// By default, WMM function will be disabled in IBSS mode

2783

ieee->current_network.QoS_Enable = 0;

2784

ieee->SetWirelessMode(ieee->dev, IEEE_G);

2785

ieee->current_network.atim_window = 0;

2786

ieee->current_network.capability = WLAN_CAPABILITY_IBSS;

2787

if(ieee->short_slot)

2788

ieee->current_network.capability |= WLAN_CAPABILITY_SHORT_SLOT;

2789

2790

}

2791

2792

ieee->state = IEEE80211_LINKED;

2793

2794

ieee->set_chan(ieee->dev, ieee->current_network.channel);

2795

ieee->link_change(ieee->dev);

2796

2797

notify_wx_assoc_event(ieee);

2798

2799

ieee80211_start_send_beacons(ieee);

2800

2801

if (ieee->data_hard_resume)

2802

ieee->data_hard_resume(ieee->dev);

2803

netif_carrier_on(ieee->dev);

2804

2805

up(&ieee->wx_sem);

2806

}

2807

2808

inline void ieee80211_start_ibss(struct ieee80211_device *ieee)

2809

{

2810

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

2811

queue_delayed_work(ieee->wq, &ieee->start_ibss_wq, 150);

2812

#else

2813

schedule_task(&ieee->start_ibss_wq);

2814

#endif

2815

}

2816

2817

/* this is called only in user context, with wx_sem held */

2818

void ieee80211_start_bss(struct ieee80211_device *ieee)

2819

{

2820

unsigned long flags;

2821

#ifdef ENABLE_DOT11D

2822

2823

// Ref: 802.11d 11.1.3.3

2824

// STA shall not start a BSS unless properly formed Beacon frame including a Country IE.

2825

2826

if(IS_DOT11D_ENABLE(ieee) && !IS_COUNTRY_IE_VALID(ieee))

2827

{

2828

if(! ieee->bGlobalDomain)

2829

{

2830

return;

2831

}

2832

}

2833

#endif

2834

/* check if we have already found the net we

2835

* are interested in (if any).

2836

* if not (we are disassociated and we are not

2837

* in associating / authenticating phase) start the background scanning.

2838

2839

ieee80211_softmac_check_all_nets(ieee);

2840

2841

/* ensure no-one start an associating process (thus setting

2842

* the ieee->state to ieee80211_ASSOCIATING) while we

2843

* have just cheked it and we are going to enable scan.

2844

* The ieee80211_new_net function is always called with

2845

* lock held (from both ieee80211_softmac_check_all_nets and

2846

* the rx path), so we cannot be in the middle of such function

2847

2848

spin_lock_irqsave(&ieee->lock, flags);

2849

2850

if (ieee->state == IEEE80211_NOLINK){

2851

#ifdef ENABLE_IPS

2852

if(ieee->ieee80211_ips_leave_wq != NULL)

2853

ieee->ieee80211_ips_leave_wq(ieee->dev);

2854

#endif

2855

ieee->actscanning = true;

2856

ieee80211_rtl_start_scan(ieee);

2857

}

2858

spin_unlock_irqrestore(&ieee->lock, flags);

2859

}

2860

2861

/* called only in userspace context */

2862

void ieee80211_disassociate(struct ieee80211_device *ieee)

2863

{

2864

2865

2866

netif_carrier_off(ieee->dev);

2867

if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)

2868

ieee80211_reset_queue(ieee);

2869

2870

if (ieee->data_hard_stop)

2871

ieee->data_hard_stop(ieee->dev);

2872

#ifdef ENABLE_DOT11D

2873

if(IS_DOT11D_ENABLE(ieee))

2874

Dot11d_Reset(ieee);

2875

#endif

2876

ieee->state = IEEE80211_NOLINK;

2877

ieee->is_set_key = false;

2878

ieee->link_change(ieee->dev);

2879

//HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);

2880

notify_wx_assoc_event(ieee);

2881

2882

}

2883

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))

2884

void ieee80211_associate_retry_wq(struct work_struct *work)

2885

{

2886

struct delayed_work *dwork = container_of(work, struct delayed_work, work);

2887

struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, associate_retry_wq);

2888

#else

2889

void ieee80211_associate_retry_wq(struct ieee80211_device *ieee)

2890

{

2891

#endif

2892

unsigned long flags;

2893

2894

down(&ieee->wx_sem);

2895

if(!ieee->proto_started)

2896

goto exit;

2897

2898

if(ieee->state != IEEE80211_ASSOCIATING_RETRY)

2899

goto exit;

2900

2901

/* until we do not set the state to IEEE80211_NOLINK

2902

* there are no possibility to have someone else trying

2903

* to start an association procdure (we get here with

2904

* ieee->state = IEEE80211_ASSOCIATING).

2905

* When we set the state to IEEE80211_NOLINK it is possible

2906

* that the RX path run an attempt to associate, but

2907

* both ieee80211_softmac_check_all_nets and the

2908

* RX path works with ieee->lock held so there are no

2909

* problems. If we are still disassociated then start a scan.

2910

* the lock here is necessary to ensure no one try to start

2911

* an association procedure when we have just checked the

2912

* state and we are going to start the scan.

2913

2914

ieee->beinretry = true;

2915

ieee->state = IEEE80211_NOLINK;

2916

2917

ieee80211_softmac_check_all_nets(ieee);

2918

2919

spin_lock_irqsave(&ieee->lock, flags);

2920

2921

if(ieee->state == IEEE80211_NOLINK)

2922

{

2923

ieee->is_roaming= false;

2924

ieee->actscanning = true;

2925

ieee80211_rtl_start_scan(ieee);

2926

}

2927

spin_unlock_irqrestore(&ieee->lock, flags);

2928

2929

ieee->beinretry = false;

2930

exit:

2931

up(&ieee->wx_sem);

2932

}

2933

2934

struct sk_buff *ieee80211_get_beacon_(struct ieee80211_device *ieee)

2935

{

2936

u8 broadcast_addr[] = {0xff,0xff,0xff,0xff,0xff,0xff};

2937

2938

struct sk_buff *skb;

2939

struct ieee80211_probe_response *b;

2940

2941

skb = ieee80211_probe_resp(ieee, broadcast_addr);

2942

2943

if (!skb)

2944

return NULL;

2945

2946

b = (struct ieee80211_probe_response *) skb->data;

2947

b->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_BEACON);

2948

2949

return skb;

2950

2951

}

2952

2953

struct sk_buff *ieee80211_get_beacon(struct ieee80211_device *ieee)

2954

{

2955

struct sk_buff *skb;

2956

struct ieee80211_probe_response *b;

2957

2958

skb = ieee80211_get_beacon_(ieee);

2959

if(!skb)

2960

return NULL;

2961

2962

b = (struct ieee80211_probe_response *) skb->data;

2963

b->header.seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4);

2964

2965

if (ieee->seq_ctrl[0] == 0xFFF)

2966

ieee->seq_ctrl[0] = 0;

2967

else

2968

ieee->seq_ctrl[0]++;

2969

2970

return skb;

2971

}

2972

2973

void ieee80211_softmac_stop_protocol(struct ieee80211_device *ieee, u8 shutdown)

2974

{

2975

ieee->sync_scan_hurryup = 1;

2976

down(&ieee->wx_sem);

2977

ieee80211_stop_protocol(ieee, shutdown);

2978

up(&ieee->wx_sem);

2979

}

2980

2981

2982

void ieee80211_stop_protocol(struct ieee80211_device *ieee, u8 shutdown)

2983

{

2984

if (!ieee->proto_started)

2985

return;

2986

2987

if(shutdown)

2988

ieee->proto_started = 0;

2989

ieee->proto_stoppping = 1;

2990

2991

ieee80211_stop_send_beacons(ieee);

2992

del_timer_sync(&ieee->associate_timer);

2993

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

2994

cancel_delayed_work(&ieee->associate_retry_wq);

2995

cancel_delayed_work(&ieee->start_ibss_wq);

2996

#endif

2997

ieee80211_stop_scan(ieee);

2998

2999

ieee80211_disassociate(ieee);

3000

RemoveAllTS(ieee); //added as we disconnect from the previous BSS, Remove all TS

3001

3002

ieee->proto_stoppping = 0;

3003

}

3004

3005

void ieee80211_softmac_start_protocol(struct ieee80211_device *ieee)

3006

{

3007

ieee->sync_scan_hurryup = 0;

3008

down(&ieee->wx_sem);

3009

ieee80211_start_protocol(ieee);

3010

up(&ieee->wx_sem);

3011

}

3012

3013

void ieee80211_start_protocol(struct ieee80211_device *ieee)

3014

{

3015

short ch = 0;

3016

int i = 0;

3017

if (ieee->proto_started)

3018

return;

3019

3020

ieee->proto_started = 1;

3021

3022

if (ieee->current_network.channel == 0){

3023

do{

3024

ch++;

3025

if (ch > MAX_CHANNEL_NUMBER)

3026

return; /* no channel found */

3027

#ifdef ENABLE_DOT11D

3028

}while(!GET_DOT11D_INFO(ieee)->channel_map[ch]);

3029

#else

3030

}while(!ieee->channel_map[ch]);

3031

#endif

3032

ieee->current_network.channel = ch;

3033

}

3034

3035

if (ieee->current_network.beacon_interval == 0)

3036

ieee->current_network.beacon_interval = 100;

3037

// printk("===>%s(), chan:%d\n", __FUNCTION__, ieee->current_network.channel);

3038

// ieee->set_chan(ieee->dev,ieee->current_network.channel);

3039

3040

for(i = 0; i < 17; i++) {

3041

ieee->last_rxseq_num[i] = -1;

3042

ieee->last_rxfrag_num[i] = -1;

3043

ieee->last_packet_time[i] = 0;

3044

}

3045

3046

ieee->init_wmmparam_flag = 0;//reinitialize AC_xx_PARAM registers.

3047

3048

ieee->state = IEEE80211_NOLINK;

3049

3050

3051

/* if the user set the MAC of the ad-hoc cell and then

3052

* switch to managed mode, shall we make sure that association

3053

* attempts does not fail just because the user provide the essid

3054

* and the nic is still checking for the AP MAC ??

3055

3056

if (ieee->iw_mode == IW_MODE_INFRA)

3057

ieee80211_start_bss(ieee);

3058

3059

else if (ieee->iw_mode == IW_MODE_ADHOC)

3060

ieee80211_start_ibss(ieee);

3061

3062

else if (ieee->iw_mode == IW_MODE_MASTER)

3063

ieee80211_start_master_bss(ieee);

3064

3065

else if(ieee->iw_mode == IW_MODE_MONITOR)

3066

ieee80211_start_monitor_mode(ieee);

3067

}

3068

3069

3070

#define DRV_NAME "Ieee80211"

3071

void ieee80211_softmac_init(struct ieee80211_device *ieee)

3072

{

3073

int i;

3074

memset(&ieee->current_network, 0, sizeof(struct ieee80211_network));

3075

3076

ieee->state = IEEE80211_NOLINK;

3077

ieee->sync_scan_hurryup = 0;

3078

for(i = 0; i < 5; i++) {

3079

ieee->seq_ctrl[i] = 0;

3080

}

3081

#ifdef ENABLE_DOT11D

3082

ieee->pDot11dInfo = kzalloc(sizeof(RT_DOT11D_INFO), GFP_ATOMIC);

3083

if (!ieee->pDot11dInfo)

3084

IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for DOT11D\n");

3085

#endif

3086

//added for AP roaming

3087

ieee->LinkDetectInfo.SlotNum = 2;

3088

ieee->LinkDetectInfo.NumRecvBcnInPeriod=0;

3089

ieee->LinkDetectInfo.NumRecvDataInPeriod=0;

3090

3091

ieee->assoc_id = 0;

3092

ieee->queue_stop = 0;

3093

ieee->scanning = 0;

3094

ieee->softmac_features = 0; //so IEEE2100-like driver are happy

3095

ieee->wap_set = 0;

3096

ieee->ssid_set = 0;

3097

ieee->proto_started = 0;

3098

ieee->basic_rate = IEEE80211_DEFAULT_BASIC_RATE;

3099

ieee->rate = 22;

3100

ieee->ps = IEEE80211_PS_DISABLED;

3101

ieee->sta_sleep = 0;

3102

ieee->Regdot11HTOperationalRateSet[0]= 0xff;//support MCS 0~7

3103

ieee->Regdot11HTOperationalRateSet[1]= 0xff;//support MCS 8~15

3104

ieee->Regdot11HTOperationalRateSet[4]= 0x01;

3105

//added by amy

3106

ieee->actscanning = false;

3107

ieee->beinretry = false;

3108

ieee->is_set_key = false;

3109

init_mgmt_queue(ieee);

3110

3111

ieee->sta_edca_param[0] = 0x0000A403;

3112

ieee->sta_edca_param[1] = 0x0000A427;

3113

ieee->sta_edca_param[2] = 0x005E4342;

3114

ieee->sta_edca_param[3] = 0x002F3262;

3115

ieee->aggregation = true;

3116

ieee->enable_rx_imm_BA = 1;

3117

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)

3118

init_timer(&ieee->scan_timer);

3119

ieee->scan_timer.data = (unsigned long)ieee;

3120

ieee->scan_timer.function = ieee80211_softmac_scan_cb;

3121

#endif

3122

ieee->tx_pending.txb = NULL;

3123

3124

init_timer(&ieee->associate_timer);

3125

ieee->associate_timer.data = (unsigned long)ieee;

3126

ieee->associate_timer.function = ieee80211_associate_abort_cb;

3127

3128

init_timer(&ieee->beacon_timer);

3129

ieee->beacon_timer.data = (unsigned long) ieee;

3130

ieee->beacon_timer.function = ieee80211_send_beacon_cb;

3131

3132

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

3133

#ifdef PF_SYNCTHREAD

3134

ieee->wq = create_workqueue(DRV_NAME,0);

3135

#else

3136

ieee->wq = create_workqueue(DRV_NAME);

3137

#endif

3138

#endif

3139

3140

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

3141

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)

3142

INIT_DELAYED_WORK(&ieee->start_ibss_wq,ieee80211_start_ibss_wq);

3143

INIT_WORK(&ieee->associate_complete_wq, ieee80211_associate_complete_wq);

3144

INIT_WORK(&ieee->associate_procedure_wq, ieee80211_associate_procedure_wq);

3145

INIT_DELAYED_WORK(&ieee->softmac_scan_wq,ieee80211_softmac_scan_wq);

3146

INIT_DELAYED_WORK(&ieee->associate_retry_wq, ieee80211_associate_retry_wq);

3147

INIT_WORK(&ieee->wx_sync_scan_wq,ieee80211_wx_sync_scan_wq);

3148

3149

#else

3150

INIT_WORK(&ieee->start_ibss_wq,(void(*)(void*)) ieee80211_start_ibss_wq,ieee);

3151

INIT_WORK(&ieee->associate_retry_wq,(void(*)(void*)) ieee80211_associate_retry_wq,ieee);

3152

INIT_WORK(&ieee->associate_complete_wq,(void(*)(void*)) ieee80211_associate_complete_wq,ieee);

3153

INIT_WORK(&ieee->associate_procedure_wq,(void(*)(void*)) ieee80211_associate_procedure_wq,ieee);

3154

INIT_WORK(&ieee->softmac_scan_wq,(void(*)(void*)) ieee80211_softmac_scan_wq,ieee);

3155

INIT_WORK(&ieee->wx_sync_scan_wq,(void(*)(void*)) ieee80211_wx_sync_scan_wq,ieee);

3156

#endif

3157

3158

#else

3159

tq_init(&ieee->start_ibss_wq,(void(*)(void*)) ieee80211_start_ibss_wq,ieee);

3160

tq_init(&ieee->associate_retry_wq,(void(*)(void*)) ieee80211_associate_retry_wq,ieee);

3161

tq_init(&ieee->associate_complete_wq,(void(*)(void*)) ieee80211_associate_complete_wq,ieee);

3162

tq_init(&ieee->associate_procedure_wq,(void(*)(void*)) ieee80211_associate_procedure_wq,ieee);

3163

tq_init(&ieee->softmac_scan_wq,(void(*)(void*)) ieee80211_softmac_scan_wq,ieee);

3164

tq_init(&ieee->wx_sync_scan_wq,(void(*)(void*)) ieee80211_wx_sync_scan_wq,ieee);

3165

#endif

3166

sema_init(&ieee->wx_sem, 1);

3167

sema_init(&ieee->scan_sem, 1);

3168

#ifdef ENABLE_IPS

3169

sema_init(&ieee->ips_sem,1);

3170

#endif

3171

spin_lock_init(&ieee->mgmt_tx_lock);

3172

spin_lock_init(&ieee->beacon_lock);

3173

3174

tasklet_init(&ieee->ps_task,

3175

(void(*)(unsigned long)) ieee80211_sta_ps,

3176

(unsigned long)ieee);

3177

3178

}

3179

3180

void ieee80211_softmac_free(struct ieee80211_device *ieee)

3181

{

3182

down(&ieee->wx_sem);

3183

#ifdef ENABLE_DOT11D

3184

if(NULL != ieee->pDot11dInfo)

3185

{

3186

kfree(ieee->pDot11dInfo);

3187

ieee->pDot11dInfo = NULL;

3188

}

3189

#endif

3190

del_timer_sync(&ieee->associate_timer);

3191

3192

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)

3193

cancel_delayed_work(&ieee->associate_retry_wq);

3194

destroy_workqueue(ieee->wq);

3195

#endif

3196

3197

up(&ieee->wx_sem);

3198

}

3199

3200

/********************************************************

3201

* Start of WPA code. *

3202

* this is stolen from the ipw2200 driver *

3203

********************************************************/

3204

3205

3206

static int ieee80211_wpa_enable(struct ieee80211_device *ieee, int value)

3207

{

3208

/* This is called when wpa_supplicant loads and closes the driver

3209

* interface. */

3210

printk("%s WPA\n",value ? "enabling" : "disabling");

3211

ieee->wpa_enabled = value;

3212

return 0;

3213

}

3214

3215

3216

void ieee80211_wpa_assoc_frame(struct ieee80211_device *ieee, char *wpa_ie, int wpa_ie_len)

3217

{

3218

/* make sure WPA is enabled */

3219

ieee80211_wpa_enable(ieee, 1);

3220

3221

ieee80211_disassociate(ieee);

3222

}

3223

3224

3225

static int ieee80211_wpa_mlme(struct ieee80211_device *ieee, int command, int reason)

3226

{

3227

3228

int ret = 0;

3229

3230

switch (command) {

3231

case IEEE_MLME_STA_DEAUTH:

3232

// silently ignore

3233

break;

3234

3235

case IEEE_MLME_STA_DISASSOC:

3236

ieee80211_disassociate(ieee);

3237

break;

3238

3239

default:

3240

printk("Unknown MLME request: %d\n", command);

3241

ret = -EOPNOTSUPP;

3242

}

3243

3244

return ret;

3245

}

3246

3247

3248

static int ieee80211_wpa_set_wpa_ie(struct ieee80211_device *ieee,

3249

struct ieee_param *param, int plen)

3250

{

3251

u8 *buf;

3252

3253

if (param->u.wpa_ie.len > MAX_WPA_IE_LEN ||

3254

(param->u.wpa_ie.len && param->u.wpa_ie.data == NULL))

3255

return -EINVAL;

3256

3257

if (param->u.wpa_ie.len) {

3258

buf = kmemdup(param->u.wpa_ie.data, param->u.wpa_ie.len,

3259

GFP_KERNEL);

3260

if (buf == NULL)

3261

return -ENOMEM;

3262

3263

kfree(ieee->wpa_ie);

3264

ieee->wpa_ie = buf;

3265

ieee->wpa_ie_len = param->u.wpa_ie.len;

3266

} else {

3267

kfree(ieee->wpa_ie);

3268

ieee->wpa_ie = NULL;

3269

ieee->wpa_ie_len = 0;

3270

}

3271

3272

ieee80211_wpa_assoc_frame(ieee, ieee->wpa_ie, ieee->wpa_ie_len);

3273

return 0;

3274

}

3275

3276

#define AUTH_ALG_OPEN_SYSTEM 0x1

3277

#define AUTH_ALG_SHARED_KEY 0x2

3278

3279

static int ieee80211_wpa_set_auth_algs(struct ieee80211_device *ieee, int value)

3280

{

3281

3282

struct ieee80211_security sec = {

3283

.flags = SEC_AUTH_MODE,

3284

};

3285

int ret = 0;

3286

3287

if (value & AUTH_ALG_SHARED_KEY) {

3288

sec.auth_mode = WLAN_AUTH_SHARED_KEY;

3289

ieee->open_wep = 0;

3290

ieee->auth_mode = 1;

3291

} else if (value & AUTH_ALG_OPEN_SYSTEM){

3292

sec.auth_mode = WLAN_AUTH_OPEN;

3293

ieee->open_wep = 1;

3294

ieee->auth_mode = 0;

3295

}

3296

else if (value & IW_AUTH_ALG_LEAP){

3297

sec.auth_mode = WLAN_AUTH_LEAP;

3298

ieee->open_wep = 1;

3299

ieee->auth_mode = 2;

3300

}

3301

3302

3303

if (ieee->set_security)

3304

ieee->set_security(ieee->dev, &sec);

3305

//else

3306

// ret = -EOPNOTSUPP;

3307

3308

return ret;

3309

}

3310

3311

static int ieee80211_wpa_set_param(struct ieee80211_device *ieee, u8 name, u32 value)

3312

{

3313

int ret=0;

3314

unsigned long flags;

3315

3316

switch (name) {

3317

case IEEE_PARAM_WPA_ENABLED:

3318

ret = ieee80211_wpa_enable(ieee, value);

3319

break;

3320

3321

case IEEE_PARAM_TKIP_COUNTERMEASURES:

3322

ieee->tkip_countermeasures=value;

3323

break;

3324

3325

case IEEE_PARAM_DROP_UNENCRYPTED: {

3326

/* HACK:

3327

3328

* wpa_supplicant calls set_wpa_enabled when the driver

3329

* is loaded and unloaded, regardless of if WPA is being

3330

* used. No other calls are made which can be used to

3331

* determine if encryption will be used or not prior to

3332

* association being expected. If encryption is not being

3333

* used, drop_unencrypted is set to false, else true -- we

3334

* can use this to determine if the CAP_PRIVACY_ON bit should

3335

* be set.

3336

3337

struct ieee80211_security sec = {

3338

.flags = SEC_ENABLED,

3339

.enabled = value,

3340

};

3341

ieee->drop_unencrypted = value;

3342

/* We only change SEC_LEVEL for open mode. Others

3343

* are set by ipw_wpa_set_encryption.

3344

3345

if (!value) {

3346

sec.flags |= SEC_LEVEL;

3347

sec.level = SEC_LEVEL_0;

3348

}

3349

else {

3350

sec.flags |= SEC_LEVEL;

3351

sec.level = SEC_LEVEL_1;

3352

}

3353

if (ieee->set_security)

3354

ieee->set_security(ieee->dev, &sec);

3355

break;

3356

}

3357

3358

case IEEE_PARAM_PRIVACY_INVOKED:

3359

ieee->privacy_invoked=value;

3360

break;

3361

3362

case IEEE_PARAM_AUTH_ALGS:

3363

ret = ieee80211_wpa_set_auth_algs(ieee, value);

3364

break;

3365

3366

case IEEE_PARAM_IEEE_802_1X:

3367

ieee->ieee802_1x=value;

3368

break;

3369

case IEEE_PARAM_WPAX_SELECT:

3370

// added for WPA2 mixed mode

3371

spin_lock_irqsave(&ieee->wpax_suitlist_lock,flags);

3372

ieee->wpax_type_set = 1;

3373

ieee->wpax_type_notify = value;

3374

spin_unlock_irqrestore(&ieee->wpax_suitlist_lock,flags);

3375

break;

3376

3377

default:

3378

printk("Unknown WPA param: %d\n",name);

3379

ret = -EOPNOTSUPP;

3380

}

3381

3382

return ret;

3383

}

3384

3385

/* implementation borrowed from hostap driver */

3386

3387

static int ieee80211_wpa_set_encryption(struct ieee80211_device *ieee,

3388

struct ieee_param *param, int param_len)

3389

{

3390

int ret = 0;

3391

3392

struct ieee80211_crypto_ops *ops;

3393

struct ieee80211_crypt_data **crypt;

3394

3395

struct ieee80211_security sec = {

3396

.flags = 0,

3397

};

3398

3399

param->u.crypt.err = 0;

3400

param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';

3401

3402

if (param_len !=

3403

(int) ((char *) param->u.crypt.key - (char *) param) +

3404

param->u.crypt.key_len) {

3405

printk("Len mismatch %d, %d\n", param_len,

3406

param->u.crypt.key_len);

3407

return -EINVAL;

3408

}

3409

if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&

3410

param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&

3411

param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {

3412

if (param->u.crypt.idx >= WEP_KEYS)

3413

return -EINVAL;

3414

crypt = &ieee->crypt[param->u.crypt.idx];

3415

} else {

3416

return -EINVAL;

3417

}

3418

3419

if (strcmp(param->u.crypt.alg, "none") == 0) {

3420

if (crypt) {

3421

sec.enabled = 0;

3422

// FIXME FIXME

3423

//sec.encrypt = 0;

3424

sec.level = SEC_LEVEL_0;

3425

sec.flags |= SEC_ENABLED | SEC_LEVEL;

3426

ieee80211_crypt_delayed_deinit(ieee, crypt);

3427

}

3428

goto done;

3429

}

3430

sec.enabled = 1;

3431

// FIXME FIXME

3432

// sec.encrypt = 1;

3433

sec.flags |= SEC_ENABLED;

3434

3435

/* IPW HW cannot build TKIP MIC, host decryption still needed. */

3436

if (!(ieee->host_encrypt || ieee->host_decrypt) &&

3437

strcmp(param->u.crypt.alg, "TKIP"))

3438

goto skip_host_crypt;

3439

3440

ops = ieee80211_get_crypto_ops(param->u.crypt.alg);

3441

if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0)

3442

ops = ieee80211_get_crypto_ops(param->u.crypt.alg);

3443

/* set WEP40 first, it will be modified according to WEP104 or

3444

* WEP40 at other place */

3445

else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0)

3446

ops = ieee80211_get_crypto_ops(param->u.crypt.alg);

3447

else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0)

3448

ops = ieee80211_get_crypto_ops(param->u.crypt.alg);

3449

if (ops == NULL) {

3450

printk("unknown crypto alg '%s'\n", param->u.crypt.alg);

3451

param->u.crypt.err = IEEE_CRYPT_ERR_UNKNOWN_ALG;

3452

ret = -EINVAL;

3453

goto done;

3454

}

3455

3456

if (*crypt == NULL || (*crypt)->ops != ops) {

3457

struct ieee80211_crypt_data *new_crypt;

3458

3459

ieee80211_crypt_delayed_deinit(ieee, crypt);

3460

3461

new_crypt = kmalloc(sizeof(*new_crypt), GFP_KERNEL);

3462

if (new_crypt == NULL) {

3463

ret = -ENOMEM;

3464

goto done;

3465

}

3466

memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));

3467

new_crypt->ops = ops;

3468

if (new_crypt->ops)

3469

new_crypt->priv =

3470

new_crypt->ops->init(param->u.crypt.idx);

3471

3472

if (new_crypt->priv == NULL) {

3473

kfree(new_crypt);

3474

param->u.crypt.err = IEEE_CRYPT_ERR_CRYPT_INIT_FAILED;

3475

ret = -EINVAL;

3476

goto done;

3477

}

3478

3479

*crypt = new_crypt;

3480

}

3481

3482

if (param->u.crypt.key_len > 0 && (*crypt)->ops->set_key &&

3483

(*crypt)->ops->set_key(param->u.crypt.key,

3484

param->u.crypt.key_len, param->u.crypt.seq,

3485

(*crypt)->priv) < 0) {

3486

printk("key setting failed\n");

3487

param->u.crypt.err = IEEE_CRYPT_ERR_KEY_SET_FAILED;

3488

ret = -EINVAL;

3489

goto done;

3490

}

3491

3492

skip_host_crypt:

3493

if (param->u.crypt.set_tx) {

3494

ieee->tx_keyidx = param->u.crypt.idx;

3495

sec.active_key = param->u.crypt.idx;

3496

sec.flags |= SEC_ACTIVE_KEY;

3497

} else

3498

sec.flags &= ~SEC_ACTIVE_KEY;

3499

3500

if (param->u.crypt.alg != NULL) {

3501

memcpy(sec.keys[param->u.crypt.idx],

3502

param->u.crypt.key,

3503

param->u.crypt.key_len);

3504

sec.key_sizes[param->u.crypt.idx] = param->u.crypt.key_len;

3505

sec.flags |= (1 << param->u.crypt.idx);

3506

3507

if (strcmp(param->u.crypt.alg, "WEP") == 0) {

3508

sec.flags |= SEC_LEVEL;

3509

sec.level = SEC_LEVEL_1;

3510

} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {

3511

sec.flags |= SEC_LEVEL;

3512

sec.level = SEC_LEVEL_2;

3513

} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {

3514

sec.flags |= SEC_LEVEL;

3515

sec.level = SEC_LEVEL_3;

3516

}

3517

}

3518

done:

3519

if (ieee->set_security)

3520

ieee->set_security(ieee->dev, &sec);

3521

3522

/* Do not reset port if card is in Managed mode since resetting will

3523

* generate new IEEE 802.11 authentication which may end up in looping

3524

* with IEEE 802.1X. If your hardware requires a reset after WEP

3525

* configuration (for example... Prism2), implement the reset_port in

3526

* the callbacks structures used to initialize the 802.11 stack. */

3527

if (ieee->reset_on_keychange &&

3528

ieee->iw_mode != IW_MODE_INFRA &&

3529

ieee->reset_port &&

3530

ieee->reset_port(ieee->dev)) {

3531

printk("reset_port failed\n");

3532

param->u.crypt.err = IEEE_CRYPT_ERR_CARD_CONF_FAILED;

3533

return -EINVAL;

3534

}

3535

3536

return ret;

3537

}

3538

3539

inline struct sk_buff *ieee80211_disassociate_skb(

3540

struct ieee80211_network *beacon,

3541

struct ieee80211_device *ieee,

3542

u8 asRsn)

3543

{

3544

struct sk_buff *skb;

3545

struct ieee80211_disassoc *disass;

3546

3547

skb = dev_alloc_skb(sizeof(struct ieee80211_disassoc));

3548

if (!skb)

3549

return NULL;

3550

3551

disass = (struct ieee80211_disassoc *) skb_put(skb,sizeof(struct ieee80211_disassoc));

3552

disass->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_DISASSOC);

3553

disass->header.duration_id = 0;

3554

3555

memcpy(disass->header.addr1, beacon->bssid, ETH_ALEN);

3556

memcpy(disass->header.addr2, ieee->dev->dev_addr, ETH_ALEN);

3557

memcpy(disass->header.addr3, beacon->bssid, ETH_ALEN);

3558

3559

disass->reason = asRsn;

3560

return skb;

3561

}

3562

3563

3564

void

3565

SendDisassociation(

3566

struct ieee80211_device *ieee,

3567

u8* asSta,

3568

u8 asRsn

3569

)

3570

{

3571

struct ieee80211_network *beacon = &ieee->current_network;

3572

struct sk_buff *skb;

3573

skb = ieee80211_disassociate_skb(beacon,ieee,asRsn);

3574

if (skb){

3575

softmac_mgmt_xmit(skb, ieee);

3576

//dev_kfree_skb_any(skb);//edit by thomas

3577

}

3578

}

3579

3580

int ieee80211_wpa_supplicant_ioctl(struct ieee80211_device *ieee, struct iw_point *p)

3581

{

3582

struct ieee_param *param;

3583

int ret=0;

3584

3585

down(&ieee->wx_sem);

3586

//IEEE_DEBUG_INFO("wpa_supplicant: len=%d\n", p->length);

3587

3588

if (p->length < sizeof(struct ieee_param) || !p->pointer){

3589

ret = -EINVAL;

3590

goto out;

3591

}

3592

3593

param = kmalloc(p->length, GFP_KERNEL);

3594

if (param == NULL){

3595

ret = -ENOMEM;

3596

goto out;

3597

}

3598

if (copy_from_user(param, p->pointer, p->length)) {

3599

kfree(param);

3600

ret = -EFAULT;

3601

goto out;

3602

}

3603

3604

switch (param->cmd) {

3605

3606

case IEEE_CMD_SET_WPA_PARAM:

3607

ret = ieee80211_wpa_set_param(ieee, param->u.wpa_param.name,

3608

param->u.wpa_param.value);

3609

break;

3610

3611

case IEEE_CMD_SET_WPA_IE:

3612

ret = ieee80211_wpa_set_wpa_ie(ieee, param, p->length);

3613

break;

3614

3615

case IEEE_CMD_SET_ENCRYPTION:

3616

ret = ieee80211_wpa_set_encryption(ieee, param, p->length);

3617

break;

3618

3619

case IEEE_CMD_MLME:

3620

ret = ieee80211_wpa_mlme(ieee, param->u.mlme.command,

3621

param->u.mlme.reason_code);

3622

break;

3623

3624

default:

3625

printk("Unknown WPA supplicant request: %d\n",param->cmd);

3626

ret = -EOPNOTSUPP;

3627

break;

3628

}

3629

3630

if (ret == 0 && copy_to_user(p->pointer, param, p->length))

3631

ret = -EFAULT;

3632

3633

kfree(param);

3634

out:

3635

up(&ieee->wx_sem);

3636

3637

return ret;

3638

}

3639

3640

void notify_wx_assoc_event(struct ieee80211_device *ieee)

3641

{

3642

union iwreq_data wrqu;

3643

wrqu.ap_addr.sa_family = ARPHRD_ETHER;

3644

if (ieee->state == IEEE80211_LINKED)

3645

memcpy(wrqu.ap_addr.sa_data, ieee->current_network.bssid, ETH_ALEN);

3646

else

3647

memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);

3648

wireless_send_event(ieee->dev, SIOCGIWAP, &wrqu, NULL);

3649

}

3650

3651

#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))

3652

//EXPORT_SYMBOL(ieee80211_get_beacon);

3653

//EXPORT_SYMBOL(ieee80211_rtl_wake_queue);

3654

//EXPORT_SYMBOL(ieee80211_rtl_stop_queue);

3655

//EXPORT_SYMBOL(ieee80211_reset_queue);

3656

//EXPORT_SYMBOL(ieee80211_softmac_stop_protocol);

3657

//EXPORT_SYMBOL(ieee80211_softmac_start_protocol);

3658

//EXPORT_SYMBOL(ieee80211_is_shortslot);

3659

//EXPORT_SYMBOL(ieee80211_is_54g);

3660

//EXPORT_SYMBOL(ieee80211_wpa_supplicant_ioctl);

3661

//EXPORT_SYMBOL(ieee80211_ps_tx_ack);

3662

//EXPORT_SYMBOL(ieee80211_softmac_xmit);

3663

//EXPORT_SYMBOL(ieee80211_stop_send_beacons);

3664

//EXPORT_SYMBOL(notify_wx_assoc_event);

3665

//EXPORT_SYMBOL(SendDisassociation);

3666

//EXPORT_SYMBOL(ieee80211_disassociate);

3667

//EXPORT_SYMBOL(ieee80211_start_send_beacons);

3668

//EXPORT_SYMBOL(ieee80211_stop_scan);

3669

//EXPORT_SYMBOL(ieee80211_send_probe_requests);

3670

//EXPORT_SYMBOL(ieee80211_softmac_scan_syncro);

3671

//EXPORT_SYMBOL(ieee80211_start_scan_syncro);

3672

#else

3673

EXPORT_SYMBOL_NOVERS(ieee80211_get_beacon);

3674

EXPORT_SYMBOL_NOVERS(ieee80211_rtl_wake_queue);

3675

EXPORT_SYMBOL_NOVERS(ieee80211_rtl_stop_queue);

3676

EXPORT_SYMBOL_NOVERS(ieee80211_reset_queue);

3677

EXPORT_SYMBOL_NOVERS(ieee80211_softmac_stop_protocol);

3678

EXPORT_SYMBOL_NOVERS(ieee80211_softmac_start_protocol);

3679

EXPORT_SYMBOL_NOVERS(ieee80211_is_shortslot);

3680

EXPORT_SYMBOL_NOVERS(ieee80211_is_54g);

3681

EXPORT_SYMBOL_NOVERS(ieee80211_wpa_supplicant_ioctl);

3682

EXPORT_SYMBOL_NOVERS(ieee80211_ps_tx_ack);

3683

EXPORT_SYMBOL_NOVERS(ieee80211_softmac_xmit);

3684

EXPORT_SYMBOL_NOVERS(ieee80211_stop_send_beacons);

3685

EXPORT_SYMBOL_NOVERS(notify_wx_assoc_event);

3686

EXPORT_SYMBOL_NOVERS(SendDisassociation);

3687

EXPORT_SYMBOL_NOVERS(ieee80211_disassociate);

3688

EXPORT_SYMBOL_NOVERS(ieee80211_start_send_beacons);

3689

EXPORT_SYMBOL_NOVERS(ieee80211_stop_scan);

3690

EXPORT_SYMBOL_NOVERS(ieee80211_send_probe_requests);

3691

EXPORT_SYMBOL_NOVERS(ieee80211_softmac_scan_syncro);

3692

EXPORT_SYMBOL_NOVERS(ieee80211_start_scan_syncro);

3693

EXPORT_SYMBOL_NOVERS(ieee80211_sta_ps_send_null_frame);

3694

EXPORT_SYMBOL_NOVERS(ieee80211_sta_ps_send_pspoll_frame);

3695

#endif

Older »