Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* BSS client mode implementation

2

* BSS client mode implementation

3

4

5

6

7

8

*

8

*

9

* This program is free software; you can redistribute it and/or modify

9

* This program is free software; you can redistribute it and/or modify

10

* it under the terms of the GNU General Public License version 2 as

10

* it under the terms of the GNU General Public License version 2 as

11

* published by the Free Software Foundation.

11

* published by the Free Software Foundation.

12

*/

12

*/

13

14

#include <linux/delay.h>

14

#include <linux/delay.h>

15

#include <linux/if_ether.h>

15

#include <linux/if_ether.h>

16

#include <linux/skbuff.h>

16

#include <linux/skbuff.h>

17

#include <linux/if_arp.h>

17

#include <linux/if_arp.h>

18

#include <linux/etherdevice.h>

18

#include <linux/etherdevice.h>

19

#include <linux/rtnetlink.h>

19

#include <linux/rtnetlink.h>

20

#include <linux/pm_qos_params.h>

20

#include <linux/pm_qos_params.h>

21

#include <linux/crc32.h>

21

#include <linux/crc32.h>

22

#include <net/mac80211.h>

22

#include <net/mac80211.h>

23

#include <asm/unaligned.h>

23

#include <asm/unaligned.h>

24

25

#include "ieee80211_i.h"

25

#include "ieee80211_i.h"

26

#include "driver-ops.h"

26

#include "driver-ops.h"

27

#include "rate.h"

27

#include "rate.h"

28

#include "led.h"

28

#include "led.h"

29

30

#define IEEE80211_AUTH_TIMEOUT (HZ / 5)

30

#define IEEE80211_AUTH_TIMEOUT (HZ / 5)

31

#define IEEE80211_AUTH_MAX_TRIES 3

31

#define IEEE80211_AUTH_MAX_TRIES 3

32

#define IEEE80211_ASSOC_TIMEOUT (HZ / 5)

32

#define IEEE80211_ASSOC_TIMEOUT (HZ / 5)

33

#define IEEE80211_ASSOC_MAX_TRIES 3

33

#define IEEE80211_ASSOC_MAX_TRIES 3

34

#define IEEE80211_MAX_PROBE_TRIES 5

34

#define IEEE80211_MAX_PROBE_TRIES 5

35

36

/*

36

/*

37

* beacon loss detection timeout

37

* beacon loss detection timeout

38

* XXX: should depend on beacon interval

38

* XXX: should depend on beacon interval

39

*/

39

*/

40

#define IEEE80211_BEACON_LOSS_TIME (2 * HZ)

40

#define IEEE80211_BEACON_LOSS_TIME (2 * HZ)

41

/*

41

/*

42

* Time the connection can be idle before we probe

42

* Time the connection can be idle before we probe

43

* it to see if we can still talk to the AP.

43

* it to see if we can still talk to the AP.

44

*/

44

*/

45

#define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)

45

#define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)

46

/*

46

/*

47

* Time we wait for a probe response after sending

47

* Time we wait for a probe response after sending

48

* a probe request because of beacon loss or for

48

* a probe request because of beacon loss or for

49

* checking the connection still works.

49

* checking the connection still works.

50

*/

50

*/

51

#define IEEE80211_PROBE_WAIT (HZ / 2)

51

#define IEEE80211_PROBE_WAIT (HZ / 2)

52

53

#define TMR_RUNNING_TIMER 0

53

#define TMR_RUNNING_TIMER 0

54

#define TMR_RUNNING_CHANSW 1

54

#define TMR_RUNNING_CHANSW 1

55

56

/*

56

/*

57

* All cfg80211 functions have to be called outside a locked

57

* All cfg80211 functions have to be called outside a locked

58

* section so that they can acquire a lock themselves... This

58

* section so that they can acquire a lock themselves... This

59

* is much simpler than queuing up things in cfg80211, but we

59

* is much simpler than queuing up things in cfg80211, but we

60

* do need some indirection for that here.

60

* do need some indirection for that here.

61

*/

61

*/

62

enum rx_mgmt_action {

62

enum rx_mgmt_action {

63

/* no action required */

63

/* no action required */

64

RX_MGMT_NONE,

64

RX_MGMT_NONE,

65

66

/* caller must call cfg80211_send_rx_auth() */

66

/* caller must call cfg80211_send_rx_auth() */

67

RX_MGMT_CFG80211_AUTH,

67

RX_MGMT_CFG80211_AUTH,

68

69

/* caller must call cfg80211_send_rx_assoc() */

69

/* caller must call cfg80211_send_rx_assoc() */

70

RX_MGMT_CFG80211_ASSOC,

70

RX_MGMT_CFG80211_ASSOC,

71

72

/* caller must call cfg80211_send_deauth() */

72

/* caller must call cfg80211_send_deauth() */

73

RX_MGMT_CFG80211_DEAUTH,

73

RX_MGMT_CFG80211_DEAUTH,

74

75

/* caller must call cfg80211_send_disassoc() */

75

/* caller must call cfg80211_send_disassoc() */

76

RX_MGMT_CFG80211_DISASSOC,

76

RX_MGMT_CFG80211_DISASSOC,

77

78

/* caller must call cfg80211_auth_timeout() & free work */

78

/* caller must call cfg80211_auth_timeout() & free work */

79

RX_MGMT_CFG80211_AUTH_TO,

79

RX_MGMT_CFG80211_AUTH_TO,

80

81

/* caller must call cfg80211_assoc_timeout() & free work */

81

/* caller must call cfg80211_assoc_timeout() & free work */

82

RX_MGMT_CFG80211_ASSOC_TO,

82

RX_MGMT_CFG80211_ASSOC_TO,

83

};

83

};

84

85

/* utils */

85

/* utils */

86

static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)

86

static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)

87

{

87

{

88

WARN_ON(!mutex_is_locked(&ifmgd->mtx));

88

WARN_ON(!mutex_is_locked(&ifmgd->mtx));

89

}

89

}

90

91

/*

91

/*

92

* We can have multiple work items (and connection probing)

92

* We can have multiple work items (and connection probing)

93

* scheduling this timer, but we need to take care to only

93

* scheduling this timer, but we need to take care to only

94

* reschedule it when it should fire _earlier_ than it was

94

* reschedule it when it should fire _earlier_ than it was

95

* asked for before, or if it's not pending right now. This

95

* asked for before, or if it's not pending right now. This

96

* function ensures that. Note that it then is required to

96

* function ensures that. Note that it then is required to

97

* run this function for all timeouts after the first one

97

* run this function for all timeouts after the first one

98

* has happened -- the work that runs from this timer will

98

* has happened -- the work that runs from this timer will

99

* do that.

99

* do that.

100

*/

100

*/

101

static void run_again(struct ieee80211_if_managed *ifmgd,

101

static void run_again(struct ieee80211_if_managed *ifmgd,

102

unsigned long timeout)

102

unsigned long timeout)

103

{

103

{

104

ASSERT_MGD_MTX(ifmgd);

104

ASSERT_MGD_MTX(ifmgd);

105

106

if (!timer_pending(&ifmgd->timer) ||

106

if (!timer_pending(&ifmgd->timer) ||

107

time_before(timeout, ifmgd->timer.expires))

107

time_before(timeout, ifmgd->timer.expires))

108

mod_timer(&ifmgd->timer, timeout);

108

mod_timer(&ifmgd->timer, timeout);

109

}

109

}

110

111

static void mod_beacon_timer(struct ieee80211_sub_if_data *sdata)

111

static void mod_beacon_timer(struct ieee80211_sub_if_data *sdata)

112

{

112

{

113

if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER)

113

if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER)

114

return;

114

return;

115

116

mod_timer(&sdata->u.mgd.bcn_mon_timer,

116

mod_timer(&sdata->u.mgd.bcn_mon_timer,

117

round_jiffies_up(jiffies + IEEE80211_BEACON_LOSS_TIME));

117

round_jiffies_up(jiffies + IEEE80211_BEACON_LOSS_TIME));

118

}

118

}

119

120

static int ecw2cw(int ecw)

120

static int ecw2cw(int ecw)

121

{

121

{

122

return (1 << ecw) - 1;

122

return (1 << ecw) - 1;

123

}

123

}

124

125

static int ieee80211_compatible_rates(struct ieee80211_bss *bss,

125

static int ieee80211_compatible_rates(struct ieee80211_bss *bss,

126

struct ieee80211_supported_band *sband,

126

struct ieee80211_supported_band *sband,

127

u32 *rates)

127

u32 *rates)

128

{

128

{

129

int i, j, count;

129

int i, j, count;

130

*rates = 0;

130

*rates = 0;

131

count = 0;

131

count = 0;

132

for (i = 0; i < bss->supp_rates_len; i++) {

132

for (i = 0; i < bss->supp_rates_len; i++) {

133

int rate = (bss->supp_rates[i] & 0x7F) * 5;

133

int rate = (bss->supp_rates[i] & 0x7F) * 5;

134

135

for (j = 0; j < sband->n_bitrates; j++)

135

for (j = 0; j < sband->n_bitrates; j++)

136

if (sband->bitrates[j].bitrate == rate) {

136

if (sband->bitrates[j].bitrate == rate) {

137

*rates |= BIT(j);

137

*rates |= BIT(j);

138

count++;

138

count++;

139

break;

139

break;

140

}

140

}

141

}

141

}

142

143

return count;

143

return count;

144

}

144

}

145

146

/*

146

/*

147

* ieee80211_enable_ht should be called only after the operating band

147

* ieee80211_enable_ht should be called only after the operating band

148

* has been determined as ht configuration depends on the hw's

148

* has been determined as ht configuration depends on the hw's

149

* HT abilities for a specific band.

149

* HT abilities for a specific band.

150

*/

150

*/

151

static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,

151

static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,

152

struct ieee80211_ht_info *hti,

152

struct ieee80211_ht_info *hti,

153

const u8 *bssid, u16 ap_ht_cap_flags)

153

const u8 *bssid, u16 ap_ht_cap_flags)

154

{

154

{

155

struct ieee80211_local *local = sdata->local;

155

struct ieee80211_local *local = sdata->local;

156

struct ieee80211_supported_band *sband;

156

struct ieee80211_supported_band *sband;

157

struct sta_info *sta;

157

struct sta_info *sta;

158

u32 changed = 0;

158

u32 changed = 0;

159

u16 ht_opmode;

159

u16 ht_opmode;

160

bool enable_ht = true, ht_changed;

160

bool enable_ht = true, ht_changed;

161

enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;

161

enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;

162

163

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

163

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

164

165

/* HT is not supported */

165

/* HT is not supported */

166

if (!sband->ht_cap.ht_supported)

166

if (!sband->ht_cap.ht_supported)

167

enable_ht = false;

167

enable_ht = false;

168

169

/* check that channel matches the right operating channel */

169

/* check that channel matches the right operating channel */

170

if (local->hw.conf.channel->center_freq !=

170

if (local->hw.conf.channel->center_freq !=

171

ieee80211_channel_to_frequency(hti->control_chan))

171

ieee80211_channel_to_frequency(hti->control_chan))

172

enable_ht = false;

172

enable_ht = false;

173

174

if (enable_ht) {

174

if (enable_ht) {

175

channel_type = NL80211_CHAN_HT20;

175

channel_type = NL80211_CHAN_HT20;

176

177

if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&

177

if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&

178

(sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&

178

(sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&

179

(hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {

179

(hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {

180

switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {

180

switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {

181

case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:

181

case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:

182

if (!(local->hw.conf.channel->flags &

182

if (!(local->hw.conf.channel->flags &

183

IEEE80211_CHAN_NO_HT40PLUS))

183

IEEE80211_CHAN_NO_HT40PLUS))

184

channel_type = NL80211_CHAN_HT40PLUS;

184

channel_type = NL80211_CHAN_HT40PLUS;

185

break;

185

break;

186

case IEEE80211_HT_PARAM_CHA_SEC_BELOW:

186

case IEEE80211_HT_PARAM_CHA_SEC_BELOW:

187

if (!(local->hw.conf.channel->flags &

187

if (!(local->hw.conf.channel->flags &

188

IEEE80211_CHAN_NO_HT40MINUS))

188

IEEE80211_CHAN_NO_HT40MINUS))

189

channel_type = NL80211_CHAN_HT40MINUS;

189

channel_type = NL80211_CHAN_HT40MINUS;

190

break;

190

break;

191

}

191

}

192

}

192

}

193

}

193

}

194

195

ht_changed = conf_is_ht(&local->hw.conf) != enable_ht ||

195

ht_changed = conf_is_ht(&local->hw.conf) != enable_ht ||

196

channel_type != local->hw.conf.channel_type;

196

channel_type != local->hw.conf.channel_type;

197

198

local->oper_channel_type = channel_type;

198

local->oper_channel_type = channel_type;

199

200

if (ht_changed) {

200

if (ht_changed) {

201

/* channel_type change automatically detected */

201

/* channel_type change automatically detected */

202

ieee80211_hw_config(local, 0);

202

ieee80211_hw_config(local, 0);

203

204

rcu_read_lock();

204

rcu_read_lock();

205

sta = sta_info_get(local, bssid);

205

sta = sta_info_get(local, bssid);

206

if (sta)

206

if (sta)

207

rate_control_rate_update(local, sband, sta,

207

rate_control_rate_update(local, sband, sta,

208

IEEE80211_RC_HT_CHANGED);

208

IEEE80211_RC_HT_CHANGED);

209

rcu_read_unlock();

209

rcu_read_unlock();

210

}

210

}

211

212

/* disable HT */

212

/* disable HT */

213

if (!enable_ht)

213

if (!enable_ht)

214

return 0;

214

return 0;

215

216

ht_opmode = le16_to_cpu(hti->operation_mode);

216

ht_opmode = le16_to_cpu(hti->operation_mode);

217

218

/* if bss configuration changed store the new one */

218

/* if bss configuration changed store the new one */

219

if (!sdata->ht_opmode_valid ||

219

if (!sdata->ht_opmode_valid ||

220

sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {

220

sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {

221

changed |= BSS_CHANGED_HT;

221

changed |= BSS_CHANGED_HT;

222

sdata->vif.bss_conf.ht_operation_mode = ht_opmode;

222

sdata->vif.bss_conf.ht_operation_mode = ht_opmode;

223

sdata->ht_opmode_valid = true;

223

sdata->ht_opmode_valid = true;

224

}

224

}

225

226

return changed;

226

return changed;

227

}

227

}

228

229

/* frame sending functions */

229

/* frame sending functions */

230

231

static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,

231

static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,

232

struct ieee80211_mgd_work *wk)

232

struct ieee80211_mgd_work *wk)

233

{

233

{

234

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

234

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

235

struct ieee80211_local *local = sdata->local;

235

struct ieee80211_local *local = sdata->local;

236

struct sk_buff *skb;

236

struct sk_buff *skb;

237

struct ieee80211_mgmt *mgmt;

237

struct ieee80211_mgmt *mgmt;

238

u8 *pos;

238

u8 *pos;

239

const u8 *ies, *ht_ie;

239

const u8 *ies, *ht_ie;

240

int i, len, count, rates_len, supp_rates_len;

240

int i, len, count, rates_len, supp_rates_len;

241

u16 capab;

241

u16 capab;

242

int wmm = 0;

242

int wmm = 0;

243

struct ieee80211_supported_band *sband;

243

struct ieee80211_supported_band *sband;

244

u32 rates = 0;

244

u32 rates = 0;

245

246

skb = dev_alloc_skb(local->hw.extra_tx_headroom +

246

skb = dev_alloc_skb(local->hw.extra_tx_headroom +

247

sizeof(*mgmt) + 200 + wk->ie_len +

247

sizeof(*mgmt) + 200 + wk->ie_len +

248

wk->ssid_len);

248

wk->ssid_len);

249

if (!skb) {

249

if (!skb) {

250

printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "

250

printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "

251

"frame\n", sdata->dev->name);

251

"frame\n", sdata->dev->name);

252

return;

252

return;

253

}

253

}

254

skb_reserve(skb, local->hw.extra_tx_headroom);

254

skb_reserve(skb, local->hw.extra_tx_headroom);

255

256

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

256

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

257

258

capab = ifmgd->capab;

258

capab = ifmgd->capab;

259

260

if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {

260

if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {

261

if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))

261

if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))

262

capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;

262

capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;

263

if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))

263

if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))

264

capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;

264

capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;

265

}

265

}

266

267

if (wk->bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)

267

if (wk->bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)

268

capab |= WLAN_CAPABILITY_PRIVACY;

268

capab |= WLAN_CAPABILITY_PRIVACY;

269

if (wk->bss->wmm_used)

269

if (wk->bss->wmm_used)

270

wmm = 1;

270

wmm = 1;

271

272

/* get all rates supported by the device and the AP as

272

/* get all rates supported by the device and the AP as

273

* some APs don't like getting a superset of their rates

273

* some APs don't like getting a superset of their rates

274

* in the association request (e.g. D-Link DAP 1353 in

274

* in the association request (e.g. D-Link DAP 1353 in

275

* b-only mode) */

275

* b-only mode) */

276

rates_len = ieee80211_compatible_rates(wk->bss, sband, &rates);

276

rates_len = ieee80211_compatible_rates(wk->bss, sband, &rates);

277

278

if ((wk->bss->cbss.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&

278

if ((wk->bss->cbss.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&

279

(local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))

279

(local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))

280

capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;

280

capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;

281

282

mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);

282

mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);

283

memset(mgmt, 0, 24);

283

memset(mgmt, 0, 24);

284

memcpy(mgmt->da, wk->bss->cbss.bssid, ETH_ALEN);

284

memcpy(mgmt->da, wk->bss->cbss.bssid, ETH_ALEN);

285

memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);

285

memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);

286

memcpy(mgmt->bssid, wk->bss->cbss.bssid, ETH_ALEN);

286

memcpy(mgmt->bssid, wk->bss->cbss.bssid, ETH_ALEN);

287

288

if (!is_zero_ether_addr(wk->prev_bssid)) {

288

if (!is_zero_ether_addr(wk->prev_bssid)) {

289

skb_put(skb, 10);

289

skb_put(skb, 10);

290

mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |

290

mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |

291

IEEE80211_STYPE_REASSOC_REQ);

291

IEEE80211_STYPE_REASSOC_REQ);

292

mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);

292

mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);

293

mgmt->u.reassoc_req.listen_interval =

293

mgmt->u.reassoc_req.listen_interval =

294

cpu_to_le16(local->hw.conf.listen_interval);

294

cpu_to_le16(local->hw.conf.listen_interval);

295

memcpy(mgmt->u.reassoc_req.current_ap, wk->prev_bssid,

295

memcpy(mgmt->u.reassoc_req.current_ap, wk->prev_bssid,

296

ETH_ALEN);

296

ETH_ALEN);

297

} else {

297

} else {

298

skb_put(skb, 4);

298

skb_put(skb, 4);

299

mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |

299

mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |

300

IEEE80211_STYPE_ASSOC_REQ);

300

IEEE80211_STYPE_ASSOC_REQ);

301

mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);

301

mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);

302

mgmt->u.assoc_req.listen_interval =

302

mgmt->u.assoc_req.listen_interval =

303

cpu_to_le16(local->hw.conf.listen_interval);

303

cpu_to_le16(local->hw.conf.listen_interval);

304

}

304

}

305

306

/* SSID */

306

/* SSID */

307

ies = pos = skb_put(skb, 2 + wk->ssid_len);

307

ies = pos = skb_put(skb, 2 + wk->ssid_len);

308

*pos++ = WLAN_EID_SSID;

308

*pos++ = WLAN_EID_SSID;

309

*pos++ = wk->ssid_len;

309

*pos++ = wk->ssid_len;

310

memcpy(pos, wk->ssid, wk->ssid_len);

310

memcpy(pos, wk->ssid, wk->ssid_len);

311

312

/* add all rates which were marked to be used above */

312

/* add all rates which were marked to be used above */

313

supp_rates_len = rates_len;

313

supp_rates_len = rates_len;

314

if (supp_rates_len > 8)

314

if (supp_rates_len > 8)

315

supp_rates_len = 8;

315

supp_rates_len = 8;

316

317

len = sband->n_bitrates;

317

len = sband->n_bitrates;

318

pos = skb_put(skb, supp_rates_len + 2);

318

pos = skb_put(skb, supp_rates_len + 2);

319

*pos++ = WLAN_EID_SUPP_RATES;

319

*pos++ = WLAN_EID_SUPP_RATES;

320

*pos++ = supp_rates_len;

320

*pos++ = supp_rates_len;

321

322

count = 0;

322

count = 0;

323

for (i = 0; i < sband->n_bitrates; i++) {

323

for (i = 0; i < sband->n_bitrates; i++) {

324

if (BIT(i) & rates) {

324

if (BIT(i) & rates) {

325

int rate = sband->bitrates[i].bitrate;

325

int rate = sband->bitrates[i].bitrate;

326

*pos++ = (u8) (rate / 5);

326

*pos++ = (u8) (rate / 5);

327

if (++count == 8)

327

if (++count == 8)

328

break;

328

break;

329

}

329

}

330

}

330

}

331

332

if (rates_len > count) {

332

if (rates_len > count) {

333

pos = skb_put(skb, rates_len - count + 2);

333

pos = skb_put(skb, rates_len - count + 2);

334

*pos++ = WLAN_EID_EXT_SUPP_RATES;

334

*pos++ = WLAN_EID_EXT_SUPP_RATES;

335

*pos++ = rates_len - count;

335

*pos++ = rates_len - count;

336

337

for (i++; i < sband->n_bitrates; i++) {

337

for (i++; i < sband->n_bitrates; i++) {

338

if (BIT(i) & rates) {

338

if (BIT(i) & rates) {

339

int rate = sband->bitrates[i].bitrate;

339

int rate = sband->bitrates[i].bitrate;

340

*pos++ = (u8) (rate / 5);

340

*pos++ = (u8) (rate / 5);

341

}

341

}

342

}

342

}

343

}

343

}

344

345

if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {

345

if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {

346

/* 1. power capabilities */

346

/* 1. power capabilities */

347

pos = skb_put(skb, 4);

347

pos = skb_put(skb, 4);

348

*pos++ = WLAN_EID_PWR_CAPABILITY;

348

*pos++ = WLAN_EID_PWR_CAPABILITY;

349

*pos++ = 2;

349

*pos++ = 2;

350

*pos++ = 0; /* min tx power */

350

*pos++ = 0; /* min tx power */

351

*pos++ = local->hw.conf.channel->max_power; /* max tx power */

351

*pos++ = local->hw.conf.channel->max_power; /* max tx power */

352

353

/* 2. supported channels */

353

/* 2. supported channels */

354

/* TODO: get this in reg domain format */

354

/* TODO: get this in reg domain format */

355

pos = skb_put(skb, 2 * sband->n_channels + 2);

355

pos = skb_put(skb, 2 * sband->n_channels + 2);

356

*pos++ = WLAN_EID_SUPPORTED_CHANNELS;

356

*pos++ = WLAN_EID_SUPPORTED_CHANNELS;

357

*pos++ = 2 * sband->n_channels;

357

*pos++ = 2 * sband->n_channels;

358

for (i = 0; i < sband->n_channels; i++) {

358

for (i = 0; i < sband->n_channels; i++) {

359

*pos++ = ieee80211_frequency_to_channel(

359

*pos++ = ieee80211_frequency_to_channel(

360

sband->channels[i].center_freq);

360

sband->channels[i].center_freq);

361

*pos++ = 1; /* one channel in the subband*/

361

*pos++ = 1; /* one channel in the subband*/

362

}

362

}

363

}

363

}

364

365

if (wk->ie_len && wk->ie) {

365

if (wk->ie_len && wk->ie) {

366

pos = skb_put(skb, wk->ie_len);

366

pos = skb_put(skb, wk->ie_len);

367

memcpy(pos, wk->ie, wk->ie_len);

367

memcpy(pos, wk->ie, wk->ie_len);

368

}

368

}

369

370

if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {

370

if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {

371

pos = skb_put(skb, 9);

371

pos = skb_put(skb, 9);

372

*pos++ = WLAN_EID_VENDOR_SPECIFIC;

372

*pos++ = WLAN_EID_VENDOR_SPECIFIC;

373

*pos++ = 7; /* len */

373

*pos++ = 7; /* len */

374

*pos++ = 0x00; /* Microsoft OUI 00:50:F2 */

374

*pos++ = 0x00; /* Microsoft OUI 00:50:F2 */

375

*pos++ = 0x50;

375

*pos++ = 0x50;

376

*pos++ = 0xf2;

376

*pos++ = 0xf2;

377

*pos++ = 2; /* WME */

377

*pos++ = 2; /* WME */

378

*pos++ = 0; /* WME info */

378

*pos++ = 0; /* WME info */

379

*pos++ = 1; /* WME ver */

379

*pos++ = 1; /* WME ver */

380

*pos++ = 0;

380

*pos++ = 0;

381

}

381

}

382

383

/* wmm support is a must to HT */

383

/* wmm support is a must to HT */

384

/*

384

/*

385

* IEEE802.11n does not allow TKIP/WEP as pairwise

385

* IEEE802.11n does not allow TKIP/WEP as pairwise

386

* ciphers in HT mode. We still associate in non-ht

386

* ciphers in HT mode. We still associate in non-ht

387

* mode (11a/b/g) if any one of these ciphers is

387

* mode (11a/b/g) if any one of these ciphers is

388

* configured as pairwise.

388

* configured as pairwise.

389

*/

389

*/

390

if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&

390

if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&

391

sband->ht_cap.ht_supported &&

391

sband->ht_cap.ht_supported &&

392

(ht_ie = ieee80211_bss_get_ie(&wk->bss->cbss, WLAN_EID_HT_INFORMATION)) &&

392

(ht_ie = ieee80211_bss_get_ie(&wk->bss->cbss, WLAN_EID_HT_INFORMATION)) &&

393

ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&

393

ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&

394

(!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))) {

394

(!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))) {

395

struct ieee80211_ht_info *ht_info =

395

struct ieee80211_ht_info *ht_info =

396

(struct ieee80211_ht_info *)(ht_ie + 2);

396

(struct ieee80211_ht_info *)(ht_ie + 2);

397

u16 cap = sband->ht_cap.cap;

397

u16 cap = sband->ht_cap.cap;

398

__le16 tmp;

398

__le16 tmp;

399

u32 flags = local->hw.conf.channel->flags;

399

u32 flags = local->hw.conf.channel->flags;

400

401

switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {

401

switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {

402

case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:

402

case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:

403

if (flags & IEEE80211_CHAN_NO_HT40PLUS) {

403

if (flags & IEEE80211_CHAN_NO_HT40PLUS) {

404

cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;

404

cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;

405

cap &= ~IEEE80211_HT_CAP_SGI_40;

405

cap &= ~IEEE80211_HT_CAP_SGI_40;

406

}

406

}

407

break;

407

break;

408

case IEEE80211_HT_PARAM_CHA_SEC_BELOW:

408

case IEEE80211_HT_PARAM_CHA_SEC_BELOW:

409

if (flags & IEEE80211_CHAN_NO_HT40MINUS) {

409

if (flags & IEEE80211_CHAN_NO_HT40MINUS) {

410

cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;

410

cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;

411

cap &= ~IEEE80211_HT_CAP_SGI_40;

411

cap &= ~IEEE80211_HT_CAP_SGI_40;

412

}

412

}

413

break;

413

break;

414

}

414

}

415

416

tmp = cpu_to_le16(cap);

416

tmp = cpu_to_le16(cap);

417

pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);

417

pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);

418

*pos++ = WLAN_EID_HT_CAPABILITY;

418

*pos++ = WLAN_EID_HT_CAPABILITY;

419

*pos++ = sizeof(struct ieee80211_ht_cap);

419

*pos++ = sizeof(struct ieee80211_ht_cap);

420

memset(pos, 0, sizeof(struct ieee80211_ht_cap));

420

memset(pos, 0, sizeof(struct ieee80211_ht_cap));

421

memcpy(pos, &tmp, sizeof(u16));

421

memcpy(pos, &tmp, sizeof(u16));

422

pos += sizeof(u16);

422

pos += sizeof(u16);

423

/* TODO: needs a define here for << 2 */

423

/* TODO: needs a define here for << 2 */

424

*pos++ = sband->ht_cap.ampdu_factor |

424

*pos++ = sband->ht_cap.ampdu_factor |

425

(sband->ht_cap.ampdu_density << 2);

425

(sband->ht_cap.ampdu_density << 2);

426

memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));

426

memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));

427

}

427

}

428

429

ieee80211_tx_skb(sdata, skb, 0);

429

ieee80211_tx_skb(sdata, skb, 0);

430

}

430

}

431

432

433

static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,

433

static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,

434

const u8 *bssid, u16 stype, u16 reason,

434

const u8 *bssid, u16 stype, u16 reason,

435

void *cookie)

435

void *cookie)

436

{

436

{

437

struct ieee80211_local *local = sdata->local;

437

struct ieee80211_local *local = sdata->local;

438

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

438

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

439

struct sk_buff *skb;

439

struct sk_buff *skb;

440

struct ieee80211_mgmt *mgmt;

440

struct ieee80211_mgmt *mgmt;

441

442

skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));

442

skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));

443

if (!skb) {

443

if (!skb) {

444

printk(KERN_DEBUG "%s: failed to allocate buffer for "

444

printk(KERN_DEBUG "%s: failed to allocate buffer for "

445

"deauth/disassoc frame\n", sdata->dev->name);

445

"deauth/disassoc frame\n", sdata->dev->name);

446

return;

446

return;

447

}

447

}

448

skb_reserve(skb, local->hw.extra_tx_headroom);

448

skb_reserve(skb, local->hw.extra_tx_headroom);

449

450

mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);

450

mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);

451

memset(mgmt, 0, 24);

451

memset(mgmt, 0, 24);

452

memcpy(mgmt->da, bssid, ETH_ALEN);

452

memcpy(mgmt->da, bssid, ETH_ALEN);

453

memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);

453

memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);

454

memcpy(mgmt->bssid, bssid, ETH_ALEN);

454

memcpy(mgmt->bssid, bssid, ETH_ALEN);

455

mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);

455

mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);

456

skb_put(skb, 2);

456

skb_put(skb, 2);

457

/* u.deauth.reason_code == u.disassoc.reason_code */

457

/* u.deauth.reason_code == u.disassoc.reason_code */

458

mgmt->u.deauth.reason_code = cpu_to_le16(reason);

458

mgmt->u.deauth.reason_code = cpu_to_le16(reason);

459

460

if (stype == IEEE80211_STYPE_DEAUTH)

460

if (stype == IEEE80211_STYPE_DEAUTH)

461

cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, cookie);

461

cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, cookie);

462

else

462

else

463

cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len, cookie);

463

cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len, cookie);

464

ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);

464

ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);

465

}

465

}

466

467

void ieee80211_send_pspoll(struct ieee80211_local *local,

467

void ieee80211_send_pspoll(struct ieee80211_local *local,

468

struct ieee80211_sub_if_data *sdata)

468

struct ieee80211_sub_if_data *sdata)

469

{

469

{

470

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

470

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

471

struct ieee80211_pspoll *pspoll;

471

struct ieee80211_pspoll *pspoll;

472

struct sk_buff *skb;

472

struct sk_buff *skb;

473

u16 fc;

473

u16 fc;

474

475

skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));

475

skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));

476

if (!skb) {

476

if (!skb) {

477

printk(KERN_DEBUG "%s: failed to allocate buffer for "

477

printk(KERN_DEBUG "%s: failed to allocate buffer for "

478

"pspoll frame\n", sdata->dev->name);

478

"pspoll frame\n", sdata->dev->name);

479

return;

479

return;

480

}

480

}

481

skb_reserve(skb, local->hw.extra_tx_headroom);

481

skb_reserve(skb, local->hw.extra_tx_headroom);

482

483

pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));

483

pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));

484

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

484

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

485

fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;

485

fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;

486

pspoll->frame_control = cpu_to_le16(fc);

486

pspoll->frame_control = cpu_to_le16(fc);

487

pspoll->aid = cpu_to_le16(ifmgd->aid);

487

pspoll->aid = cpu_to_le16(ifmgd->aid);

488

489

/* aid in PS-Poll has its two MSBs each set to 1 */

489

/* aid in PS-Poll has its two MSBs each set to 1 */

490

pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);

490

pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);

491

492

memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);

492

memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);

493

memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);

493

memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);

494

495

ieee80211_tx_skb(sdata, skb, 0);

495

ieee80211_tx_skb(sdata, skb, 0);

496

}

496

}

497

498

void ieee80211_send_nullfunc(struct ieee80211_local *local,

498

void ieee80211_send_nullfunc(struct ieee80211_local *local,

499

struct ieee80211_sub_if_data *sdata,

499

struct ieee80211_sub_if_data *sdata,

500

int powersave)

500

int powersave)

501

{

501

{

502

struct sk_buff *skb;

502

struct sk_buff *skb;

503

struct ieee80211_hdr *nullfunc;

503

struct ieee80211_hdr *nullfunc;

504

__le16 fc;

504

__le16 fc;

505

506

if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))

506

if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))

507

return;

507

return;

508

509

skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);

509

skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);

510

if (!skb) {

510

if (!skb) {

511

printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "

511

printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "

512

"frame\n", sdata->dev->name);

512

"frame\n", sdata->dev->name);

513

return;

513

return;

514

}

514

}

515

skb_reserve(skb, local->hw.extra_tx_headroom);

515

skb_reserve(skb, local->hw.extra_tx_headroom);

516

517

nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);

517

nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);

518

memset(nullfunc, 0, 24);

518

memset(nullfunc, 0, 24);

519

fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |

519

fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |

520

IEEE80211_FCTL_TODS);

520

IEEE80211_FCTL_TODS);

521

if (powersave)

521

if (powersave)

522

fc |= cpu_to_le16(IEEE80211_FCTL_PM);

522

fc |= cpu_to_le16(IEEE80211_FCTL_PM);

523

nullfunc->frame_control = fc;

523

nullfunc->frame_control = fc;

524

memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);

524

memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);

525

memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);

525

memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);

526

memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);

526

memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);

527

528

ieee80211_tx_skb(sdata, skb, 0);

528

ieee80211_tx_skb(sdata, skb, 0);

529

}

529

}

530

531

/* spectrum management related things */

531

/* spectrum management related things */

532

static void ieee80211_chswitch_work(struct work_struct *work)

532

static void ieee80211_chswitch_work(struct work_struct *work)

533

{

533

{

534

struct ieee80211_sub_if_data *sdata =

534

struct ieee80211_sub_if_data *sdata =

535

container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);

535

container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);

536

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

536

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

537

538

if (!netif_running(sdata->dev))

538

if (!netif_running(sdata->dev))

539

return;

539

return;

540

541

mutex_lock(&ifmgd->mtx);

541

mutex_lock(&ifmgd->mtx);

542

if (!ifmgd->associated)

542

if (!ifmgd->associated)

543

goto out;

543

goto out;

544

545

sdata->local->oper_channel = sdata->local->csa_channel;

545

sdata->local->oper_channel = sdata->local->csa_channel;

546

ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL);

546

ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL);

547

548

/* XXX: shouldn't really modify cfg80211-owned data! */

548

/* XXX: shouldn't really modify cfg80211-owned data! */

549

ifmgd->associated->cbss.channel = sdata->local->oper_channel;

549

ifmgd->associated->cbss.channel = sdata->local->oper_channel;

550

551

ieee80211_wake_queues_by_reason(&sdata->local->hw,

551

ieee80211_wake_queues_by_reason(&sdata->local->hw,

552

IEEE80211_QUEUE_STOP_REASON_CSA);

552

IEEE80211_QUEUE_STOP_REASON_CSA);

553

out:

553

out:

554

ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;

554

ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;

555

mutex_unlock(&ifmgd->mtx);

555

mutex_unlock(&ifmgd->mtx);

556

}

556

}

557

558

static void ieee80211_chswitch_timer(unsigned long data)

558

static void ieee80211_chswitch_timer(unsigned long data)

559

{

559

{

560

struct ieee80211_sub_if_data *sdata =

560

struct ieee80211_sub_if_data *sdata =

561

(struct ieee80211_sub_if_data *) data;

561

(struct ieee80211_sub_if_data *) data;

562

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

562

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

563

564

if (sdata->local->quiescing) {

564

if (sdata->local->quiescing) {

565

set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);

565

set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);

566

return;

566

return;

567

}

567

}

568

569

ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);

569

ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);

570

}

570

}

571

572

void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,

572

void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,

573

struct ieee80211_channel_sw_ie *sw_elem,

573

struct ieee80211_channel_sw_ie *sw_elem,

574

struct ieee80211_bss *bss)

574

struct ieee80211_bss *bss)

575

{

575

{

576

struct ieee80211_channel *new_ch;

576

struct ieee80211_channel *new_ch;

577

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

577

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

578

int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);

578

int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);

579

580

ASSERT_MGD_MTX(ifmgd);

580

ASSERT_MGD_MTX(ifmgd);

581

582

if (!ifmgd->associated)

582

if (!ifmgd->associated)

583

return;

583

return;

584

585

if (sdata->local->scanning)

585

if (sdata->local->scanning)

586

return;

586

return;

587

588

/* Disregard subsequent beacons if we are already running a timer

588

/* Disregard subsequent beacons if we are already running a timer

589

processing a CSA */

589

processing a CSA */

590

591

if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)

591

if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)

592

return;

592

return;

593

594

new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);

594

new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);

595

if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)

595

if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)

596

return;

596

return;

597

598

sdata->local->csa_channel = new_ch;

598

sdata->local->csa_channel = new_ch;

599

600

if (sw_elem->count <= 1) {

600

if (sw_elem->count <= 1) {

601

ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);

601

ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);

602

} else {

602

} else {

603

ieee80211_stop_queues_by_reason(&sdata->local->hw,

603

ieee80211_stop_queues_by_reason(&sdata->local->hw,

604

IEEE80211_QUEUE_STOP_REASON_CSA);

604

IEEE80211_QUEUE_STOP_REASON_CSA);

605

ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;

605

ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;

606

mod_timer(&ifmgd->chswitch_timer,

606

mod_timer(&ifmgd->chswitch_timer,

607

jiffies +

607

jiffies +

608

msecs_to_jiffies(sw_elem->count *

608

msecs_to_jiffies(sw_elem->count *

609

bss->cbss.beacon_interval));

609

bss->cbss.beacon_interval));

610

}

610

}

611

}

611

}

612

613

static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,

613

static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,

614

u16 capab_info, u8 *pwr_constr_elem,

614

u16 capab_info, u8 *pwr_constr_elem,

615

u8 pwr_constr_elem_len)

615

u8 pwr_constr_elem_len)

616

{

616

{

617

struct ieee80211_conf *conf = &sdata->local->hw.conf;

617

struct ieee80211_conf *conf = &sdata->local->hw.conf;

618

619

if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))

619

if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))

620

return;

620

return;

621

622

/* Power constraint IE length should be 1 octet */

622

/* Power constraint IE length should be 1 octet */

623

if (pwr_constr_elem_len != 1)

623

if (pwr_constr_elem_len != 1)

624

return;

624

return;

625

626

if ((*pwr_constr_elem <= conf->channel->max_power) &&

626

if ((*pwr_constr_elem <= conf->channel->max_power) &&

627

(*pwr_constr_elem != sdata->local->power_constr_level)) {

627

(*pwr_constr_elem != sdata->local->power_constr_level)) {

628

sdata->local->power_constr_level = *pwr_constr_elem;

628

sdata->local->power_constr_level = *pwr_constr_elem;

629

ieee80211_hw_config(sdata->local, 0);

629

ieee80211_hw_config(sdata->local, 0);

630

}

630

}

631

}

631

}

632

633

/* powersave */

633

/* powersave */

634

static void ieee80211_enable_ps(struct ieee80211_local *local,

634

static void ieee80211_enable_ps(struct ieee80211_local *local,

635

struct ieee80211_sub_if_data *sdata)

635

struct ieee80211_sub_if_data *sdata)

636

{

636

{

637

struct ieee80211_conf *conf = &local->hw.conf;

637

struct ieee80211_conf *conf = &local->hw.conf;

638

639

/*

639

/*

640

* If we are scanning right now then the parameters will

640

* If we are scanning right now then the parameters will

641

* take effect when scan finishes.

641

* take effect when scan finishes.

642

*/

642

*/

643

if (local->scanning)

643

if (local->scanning)

644

return;

644

return;

645

646

if (conf->dynamic_ps_timeout > 0 &&

646

if (conf->dynamic_ps_timeout > 0 &&

647

!(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {

647

!(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {

648

mod_timer(&local->dynamic_ps_timer, jiffies +

648

mod_timer(&local->dynamic_ps_timer, jiffies +

649

msecs_to_jiffies(conf->dynamic_ps_timeout));

649

msecs_to_jiffies(conf->dynamic_ps_timeout));

650

} else {

650

} else {

651

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)

651

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)

652

ieee80211_send_nullfunc(local, sdata, 1);

652

ieee80211_send_nullfunc(local, sdata, 1);

653

conf->flags |= IEEE80211_CONF_PS;

653

conf->flags |= IEEE80211_CONF_PS;

654

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

654

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

655

}

655

}

656

}

656

}

657

658

static void ieee80211_change_ps(struct ieee80211_local *local)

658

static void ieee80211_change_ps(struct ieee80211_local *local)

659

{

659

{

660

struct ieee80211_conf *conf = &local->hw.conf;

660

struct ieee80211_conf *conf = &local->hw.conf;

661

662

if (local->ps_sdata) {

662

if (local->ps_sdata) {

663

ieee80211_enable_ps(local, local->ps_sdata);

663

ieee80211_enable_ps(local, local->ps_sdata);

664

} else if (conf->flags & IEEE80211_CONF_PS) {

664

} else if (conf->flags & IEEE80211_CONF_PS) {

665

conf->flags &= ~IEEE80211_CONF_PS;

665

conf->flags &= ~IEEE80211_CONF_PS;

666

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

666

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

667

del_timer_sync(&local->dynamic_ps_timer);

667

del_timer_sync(&local->dynamic_ps_timer);

668

cancel_work_sync(&local->dynamic_ps_enable_work);

668

cancel_work_sync(&local->dynamic_ps_enable_work);

669

}

669

}

670

}

670

}

671

672

/* need to hold RTNL or interface lock */

672

/* need to hold RTNL or interface lock */

673

void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)

673

void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)

674

{

674

{

675

struct ieee80211_sub_if_data *sdata, *found = NULL;

675

struct ieee80211_sub_if_data *sdata, *found = NULL;

676

int count = 0;

676

int count = 0;

677

678

if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {

678

if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {

679

local->ps_sdata = NULL;

679

local->ps_sdata = NULL;

680

return;

680

return;

681

}

681

}

682

683

list_for_each_entry(sdata, &local->interfaces, list) {

683

list_for_each_entry(sdata, &local->interfaces, list) {

684

if (!netif_running(sdata->dev))

684

if (!netif_running(sdata->dev))

685

continue;

685

continue;

686

if (sdata->vif.type != NL80211_IFTYPE_STATION)

686

if (sdata->vif.type != NL80211_IFTYPE_STATION)

687

continue;

687

continue;

688

found = sdata;

688

found = sdata;

689

count++;

689

count++;

690

}

690

}

691

692

if (count == 1 && found->u.mgd.powersave &&

692

if (count == 1 && found->u.mgd.powersave &&

693

found->u.mgd.associated && list_empty(&found->u.mgd.work_list) &&

693

found->u.mgd.associated && list_empty(&found->u.mgd.work_list) &&

694

!(found->u.mgd.flags & (IEEE80211_STA_BEACON_POLL |

694

!(found->u.mgd.flags & (IEEE80211_STA_BEACON_POLL |

695

IEEE80211_STA_CONNECTION_POLL))) {

695

IEEE80211_STA_CONNECTION_POLL))) {

696

s32 beaconint_us;

696

s32 beaconint_us;

697

698

if (latency < 0)

698

if (latency < 0)

699

latency = pm_qos_requirement(PM_QOS_NETWORK_LATENCY);

699

latency = pm_qos_requirement(PM_QOS_NETWORK_LATENCY);

700

701

beaconint_us = ieee80211_tu_to_usec(

701

beaconint_us = ieee80211_tu_to_usec(

702

found->vif.bss_conf.beacon_int);

702

found->vif.bss_conf.beacon_int);

703

704

if (beaconint_us > latency) {

704

if (beaconint_us > latency) {

705

local->ps_sdata = NULL;

705

local->ps_sdata = NULL;

706

} else {

706

} else {

707

u8 dtimper = found->vif.bss_conf.dtim_period;

707

u8 dtimper = found->vif.bss_conf.dtim_period;

708

int maxslp = 1;

708

int maxslp = 1;

709

710

if (dtimper > 1)

710

if (dtimper > 1)

711

maxslp = min_t(int, dtimper,

711

maxslp = min_t(int, dtimper,

712

latency / beaconint_us);

712

latency / beaconint_us);

713

714

local->hw.conf.max_sleep_period = maxslp;

714

local->hw.conf.max_sleep_period = maxslp;

715

local->ps_sdata = found;

715

local->ps_sdata = found;

716

}

716

}

717

} else {

717

} else {

718

local->ps_sdata = NULL;

718

local->ps_sdata = NULL;

719

}

719

}

720

721

ieee80211_change_ps(local);

721

ieee80211_change_ps(local);

722

}

722

}

723

724

void ieee80211_dynamic_ps_disable_work(struct work_struct *work)

724

void ieee80211_dynamic_ps_disable_work(struct work_struct *work)

725

{

725

{

726

struct ieee80211_local *local =

726

struct ieee80211_local *local =

727

container_of(work, struct ieee80211_local,

727

container_of(work, struct ieee80211_local,

728

dynamic_ps_disable_work);

728

dynamic_ps_disable_work);

729

730

if (local->hw.conf.flags & IEEE80211_CONF_PS) {

730

if (local->hw.conf.flags & IEEE80211_CONF_PS) {

731

local->hw.conf.flags &= ~IEEE80211_CONF_PS;

731

local->hw.conf.flags &= ~IEEE80211_CONF_PS;

732

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

732

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

733

}

733

}

734

735

ieee80211_wake_queues_by_reason(&local->hw,

735

ieee80211_wake_queues_by_reason(&local->hw,

736

IEEE80211_QUEUE_STOP_REASON_PS);

736

IEEE80211_QUEUE_STOP_REASON_PS);

737

}

737

}

738

739

void ieee80211_dynamic_ps_enable_work(struct work_struct *work)

739

void ieee80211_dynamic_ps_enable_work(struct work_struct *work)

740

{

740

{

741

struct ieee80211_local *local =

741

struct ieee80211_local *local =

742

container_of(work, struct ieee80211_local,

742

container_of(work, struct ieee80211_local,

743

dynamic_ps_enable_work);

743

dynamic_ps_enable_work);

744

struct ieee80211_sub_if_data *sdata = local->ps_sdata;

744

struct ieee80211_sub_if_data *sdata = local->ps_sdata;

745

746

/* can only happen when PS was just disabled anyway */

746

/* can only happen when PS was just disabled anyway */

747

if (!sdata)

747

if (!sdata)

748

return;

748

return;

749

750

if (local->hw.conf.flags & IEEE80211_CONF_PS)

750

if (local->hw.conf.flags & IEEE80211_CONF_PS)

751

return;

751

return;

752

753

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)

753

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)

754

ieee80211_send_nullfunc(local, sdata, 1);

754

ieee80211_send_nullfunc(local, sdata, 1);

755

756

local->hw.conf.flags |= IEEE80211_CONF_PS;

756

local->hw.conf.flags |= IEEE80211_CONF_PS;

757

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

757

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

758

}

758

}

759

760

void ieee80211_dynamic_ps_timer(unsigned long data)

760

void ieee80211_dynamic_ps_timer(unsigned long data)

761

{

761

{

762

struct ieee80211_local *local = (void *) data;

762

struct ieee80211_local *local = (void *) data;

763

764

if (local->quiescing || local->suspended)

764

if (local->quiescing || local->suspended)

765

return;

765

return;

766

767

ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);

767

ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);

768

}

768

}

769

770

/* MLME */

770

/* MLME */

771

static void ieee80211_sta_wmm_params(struct ieee80211_local *local,

771

static void ieee80211_sta_wmm_params(struct ieee80211_local *local,

772

struct ieee80211_if_managed *ifmgd,

772

struct ieee80211_if_managed *ifmgd,

773

u8 *wmm_param, size_t wmm_param_len)

773

u8 *wmm_param, size_t wmm_param_len)

774

{

774

{

775

struct ieee80211_tx_queue_params params;

775

struct ieee80211_tx_queue_params params;

776

size_t left;

776

size_t left;

777

int count;

777

int count;

778

u8 *pos;

778

u8 *pos;

779

780

if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))

780

if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))

781

return;

781

return;

782

783

if (!wmm_param)

783

if (!wmm_param)

784

return;

784

return;

785

786

if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)

786

if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)

787

return;

787

return;

788

count = wmm_param[6] & 0x0f;

788

count = wmm_param[6] & 0x0f;

789

if (count == ifmgd->wmm_last_param_set)

789

if (count == ifmgd->wmm_last_param_set)

790

return;

790

return;

791

ifmgd->wmm_last_param_set = count;

791

ifmgd->wmm_last_param_set = count;

792

793

pos = wmm_param + 8;

793

pos = wmm_param + 8;

794

left = wmm_param_len - 8;

794

left = wmm_param_len - 8;

795

796

memset(&params, 0, sizeof(params));

796

memset(&params, 0, sizeof(params));

797

798

local->wmm_acm = 0;

798

local->wmm_acm = 0;

799

for (; left >= 4; left -= 4, pos += 4) {

799

for (; left >= 4; left -= 4, pos += 4) {

800

int aci = (pos[0] >> 5) & 0x03;

800

int aci = (pos[0] >> 5) & 0x03;

801

int acm = (pos[0] >> 4) & 0x01;

801

int acm = (pos[0] >> 4) & 0x01;

802

int queue;

802

int queue;

803

804

switch (aci) {

804

switch (aci) {

805

case 1: /* AC_BK */

805

case 1: /* AC_BK */

806

queue = 3;

806

queue = 3;

807

if (acm)

807

if (acm)

808

local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */

808

local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */

809

break;

809

break;

810

case 2: /* AC_VI */

810

case 2: /* AC_VI */

811

queue = 1;

811

queue = 1;

812

if (acm)

812

if (acm)

813

local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */

813

local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */

814

break;

814

break;

815

case 3: /* AC_VO */

815

case 3: /* AC_VO */

816

queue = 0;

816

queue = 0;

817

if (acm)

817

if (acm)

818

local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */

818

local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */

819

break;

819

break;

820

case 0: /* AC_BE */

820

case 0: /* AC_BE */

821

default:

821

default:

822

queue = 2;

822

queue = 2;

823

if (acm)

823

if (acm)

824

local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */

824

local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */

825

break;

825

break;

826

}

826

}

827

828

params.aifs = pos[0] & 0x0f;

828

params.aifs = pos[0] & 0x0f;

829

params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);

829

params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);

830

params.cw_min = ecw2cw(pos[1] & 0x0f);

830

params.cw_min = ecw2cw(pos[1] & 0x0f);

831

params.txop = get_unaligned_le16(pos + 2);

831

params.txop = get_unaligned_le16(pos + 2);

832

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

832

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

833

printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "

833

printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "

834

"cWmin=%d cWmax=%d txop=%d\n",

834

"cWmin=%d cWmax=%d txop=%d\n",

835

wiphy_name(local->hw.wiphy), queue, aci, acm,

835

wiphy_name(local->hw.wiphy), queue, aci, acm,

836

params.aifs, params.cw_min, params.cw_max, params.txop);

836

params.aifs, params.cw_min, params.cw_max, params.txop);

837

#endif

837

#endif

838

if (drv_conf_tx(local, queue, &params) && local->ops->conf_tx)

838

if (drv_conf_tx(local, queue, &params) && local->ops->conf_tx)

839

printk(KERN_DEBUG "%s: failed to set TX queue "

839

printk(KERN_DEBUG "%s: failed to set TX queue "

840

"parameters for queue %d\n",

840

"parameters for queue %d\n",

841

wiphy_name(local->hw.wiphy), queue);

841

wiphy_name(local->hw.wiphy), queue);

842

}

842

}

843

}

843

}

844

845

static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,

845

static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,

846

u16 capab, bool erp_valid, u8 erp)

846

u16 capab, bool erp_valid, u8 erp)

847

{

847

{

848

struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;

848

struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;

849

u32 changed = 0;

849

u32 changed = 0;

850

bool use_protection;

850

bool use_protection;

851

bool use_short_preamble;

851

bool use_short_preamble;

852

bool use_short_slot;

852

bool use_short_slot;

853

854

if (erp_valid) {

854

if (erp_valid) {

855

use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;

855

use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;

856

use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;

856

use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;

857

} else {

857

} else {

858

use_protection = false;

858

use_protection = false;

859

use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);

859

use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);

860

}

860

}

861

862

use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);

862

use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);

863

864

if (use_protection != bss_conf->use_cts_prot) {

864

if (use_protection != bss_conf->use_cts_prot) {

865

bss_conf->use_cts_prot = use_protection;

865

bss_conf->use_cts_prot = use_protection;

866

changed |= BSS_CHANGED_ERP_CTS_PROT;

866

changed |= BSS_CHANGED_ERP_CTS_PROT;

867

}

867

}

868

869

if (use_short_preamble != bss_conf->use_short_preamble) {

869

if (use_short_preamble != bss_conf->use_short_preamble) {

870

bss_conf->use_short_preamble = use_short_preamble;

870

bss_conf->use_short_preamble = use_short_preamble;

871

changed |= BSS_CHANGED_ERP_PREAMBLE;

871

changed |= BSS_CHANGED_ERP_PREAMBLE;

872

}

872

}

873

874

if (use_short_slot != bss_conf->use_short_slot) {

874

if (use_short_slot != bss_conf->use_short_slot) {

875

bss_conf->use_short_slot = use_short_slot;

875

bss_conf->use_short_slot = use_short_slot;

876

changed |= BSS_CHANGED_ERP_SLOT;

876

changed |= BSS_CHANGED_ERP_SLOT;

877

}

877

}

878

879

return changed;

879

return changed;

880

}

880

}

881

882

static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,

882

static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,

883

struct ieee80211_mgd_work *wk,

883

struct ieee80211_mgd_work *wk,

884

u32 bss_info_changed)

884

u32 bss_info_changed)

885

{

885

{

886

struct ieee80211_local *local = sdata->local;

886

struct ieee80211_local *local = sdata->local;

887

struct ieee80211_bss *bss = wk->bss;

887

struct ieee80211_bss *bss = wk->bss;

888

889

bss_info_changed |= BSS_CHANGED_ASSOC;

889

bss_info_changed |= BSS_CHANGED_ASSOC;

890

/* set timing information */

890

/* set timing information */

891

sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;

891

sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;

892

sdata->vif.bss_conf.timestamp = bss->cbss.tsf;

892

sdata->vif.bss_conf.timestamp = bss->cbss.tsf;

893

sdata->vif.bss_conf.dtim_period = bss->dtim_period;

893

sdata->vif.bss_conf.dtim_period = bss->dtim_period;

894

895

bss_info_changed |= BSS_CHANGED_BEACON_INT;

895

bss_info_changed |= BSS_CHANGED_BEACON_INT;

896

bss_info_changed |= ieee80211_handle_bss_capability(sdata,

896

bss_info_changed |= ieee80211_handle_bss_capability(sdata,

897

bss->cbss.capability, bss->has_erp_value, bss->erp_value);

897

bss->cbss.capability, bss->has_erp_value, bss->erp_value);

898

899

sdata->u.mgd.associated = bss;

899

sdata->u.mgd.associated = bss;

900

sdata->u.mgd.old_associate_work = wk;

900

sdata->u.mgd.old_associate_work = wk;

901

memcpy(sdata->u.mgd.bssid, bss->cbss.bssid, ETH_ALEN);

901

memcpy(sdata->u.mgd.bssid, bss->cbss.bssid, ETH_ALEN);

902

903

/* just to be sure */

903

/* just to be sure */

904

sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |

904

sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |

905

IEEE80211_STA_BEACON_POLL);

905

IEEE80211_STA_BEACON_POLL);

906

907

ieee80211_led_assoc(local, 1);

907

ieee80211_led_assoc(local, 1);

908

909

sdata->vif.bss_conf.assoc = 1;

909

sdata->vif.bss_conf.assoc = 1;

910

/*

910

/*

911

* For now just always ask the driver to update the basic rateset

911

* For now just always ask the driver to update the basic rateset

912

* when we have associated, we aren't checking whether it actually

912

* when we have associated, we aren't checking whether it actually

913

* changed or not.

913

* changed or not.

914

*/

914

*/

915

bss_info_changed |= BSS_CHANGED_BASIC_RATES;

915

bss_info_changed |= BSS_CHANGED_BASIC_RATES;

916

917

/* And the BSSID changed - we're associated now */

917

/* And the BSSID changed - we're associated now */

918

bss_info_changed |= BSS_CHANGED_BSSID;

918

bss_info_changed |= BSS_CHANGED_BSSID;

919

920

ieee80211_bss_info_change_notify(sdata, bss_info_changed);

920

ieee80211_bss_info_change_notify(sdata, bss_info_changed);

921

922

mutex_lock(&local->iflist_mtx);

922

mutex_lock(&local->iflist_mtx);

923

ieee80211_recalc_ps(local, -1);

923

ieee80211_recalc_ps(local, -1);

924

mutex_unlock(&local->iflist_mtx);

924

mutex_unlock(&local->iflist_mtx);

925

926

netif_tx_start_all_queues(sdata->dev);

926

netif_tx_start_all_queues(sdata->dev);

927

netif_carrier_on(sdata->dev);

927

netif_carrier_on(sdata->dev);

928

}

928

}

929

930

static enum rx_mgmt_action __must_check

930

static enum rx_mgmt_action __must_check

931

ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata,

931

ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata,

932

struct ieee80211_mgd_work *wk)

932

struct ieee80211_mgd_work *wk)

933

{

933

{

934

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

934

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

935

struct ieee80211_local *local = sdata->local;

935

struct ieee80211_local *local = sdata->local;

936

937

wk->tries++;

937

wk->tries++;

938

if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {

938

if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {

939

printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",

939

printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",

940

sdata->dev->name, wk->bss->cbss.bssid);

940

sdata->dev->name, wk->bss->cbss.bssid);

941

942

/*

942

/*

943

* Most likely AP is not in the range so remove the

943

* Most likely AP is not in the range so remove the

944

* bss struct for that AP.

944

* bss struct for that AP.

945

*/

945

*/

946

cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);

946

cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);

947

948

/*

948

/*

949

* We might have a pending scan which had no chance to run yet

949

* We might have a pending scan which had no chance to run yet

950

* due to work needing to be done. Hence, queue the STAs work

950

* due to work needing to be done. Hence, queue the STAs work

951

* again for that.

951

* again for that.

952

*/

952

*/

953

ieee80211_queue_work(&local->hw, &ifmgd->work);

953

ieee80211_queue_work(&local->hw, &ifmgd->work);

954

return RX_MGMT_CFG80211_AUTH_TO;

954

return RX_MGMT_CFG80211_AUTH_TO;

955

}

955

}

956

957

printk(KERN_DEBUG "%s: direct probe to AP %pM (try %d)\n",

957

printk(KERN_DEBUG "%s: direct probe to AP %pM (try %d)\n",

958

sdata->dev->name, wk->bss->cbss.bssid,

958

sdata->dev->name, wk->bss->cbss.bssid,

959

wk->tries);

959

wk->tries);

960

961

/*

961

/*

962

* Direct probe is sent to broadcast address as some APs

962

* Direct probe is sent to broadcast address as some APs

963

* will not answer to direct packet in unassociated state.

963

* will not answer to direct packet in unassociated state.

964

*/

964

*/

965

ieee80211_send_probe_req(sdata, NULL, wk->ssid, wk->ssid_len, NULL, 0);

965

ieee80211_send_probe_req(sdata, NULL, wk->ssid, wk->ssid_len, NULL, 0);

966

967

wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;

967

wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;

968

run_again(ifmgd, wk->timeout);

968

run_again(ifmgd, wk->timeout);

969

970

return RX_MGMT_NONE;

970

return RX_MGMT_NONE;

971

}

971

}

972

973

974

static enum rx_mgmt_action __must_check

974

static enum rx_mgmt_action __must_check

975

ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,

975

ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,

976

struct ieee80211_mgd_work *wk)

976

struct ieee80211_mgd_work *wk)

977

{

977

{

978

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

978

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

979

struct ieee80211_local *local = sdata->local;

979

struct ieee80211_local *local = sdata->local;

980

981

wk->tries++;

981

wk->tries++;

982

if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {

982

if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {

983

printk(KERN_DEBUG "%s: authentication with AP %pM"

983

printk(KERN_DEBUG "%s: authentication with AP %pM"

984

" timed out\n",

984

" timed out\n",

985

sdata->dev->name, wk->bss->cbss.bssid);

985

sdata->dev->name, wk->bss->cbss.bssid);

986

987

/*

987

/*

988

* Most likely AP is not in the range so remove the

988

* Most likely AP is not in the range so remove the

989

* bss struct for that AP.

989

* bss struct for that AP.

990

*/

990

*/

991

cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);

991

cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);

992

993

/*

993

/*

994

* We might have a pending scan which had no chance to run yet

994

* We might have a pending scan which had no chance to run yet

995

* due to work needing to be done. Hence, queue the STAs work

995

* due to work needing to be done. Hence, queue the STAs work

996

* again for that.

996

* again for that.

997

*/

997

*/

998

ieee80211_queue_work(&local->hw, &ifmgd->work);

998

ieee80211_queue_work(&local->hw, &ifmgd->work);

999

return RX_MGMT_CFG80211_AUTH_TO;

999

return RX_MGMT_CFG80211_AUTH_TO;

1000

}

1000

}

1001

1002

printk(KERN_DEBUG "%s: authenticate with AP %pM (try %d)\n",

1002

printk(KERN_DEBUG "%s: authenticate with AP %pM (try %d)\n",

1003

sdata->dev->name, wk->bss->cbss.bssid, wk->tries);

1003

sdata->dev->name, wk->bss->cbss.bssid, wk->tries);

1004

1005

ieee80211_send_auth(sdata, 1, wk->auth_alg, wk->ie, wk->ie_len,

1005

ieee80211_send_auth(sdata, 1, wk->auth_alg, wk->ie, wk->ie_len,

1006

wk->bss->cbss.bssid, NULL, 0, 0);

1006

wk->bss->cbss.bssid, NULL, 0, 0);

1007

wk->auth_transaction = 2;

1007

wk->auth_transaction = 2;

1008

1009

wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;

1009

wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;

1010

run_again(ifmgd, wk->timeout);

1010

run_again(ifmgd, wk->timeout);

1011

1012

return RX_MGMT_NONE;

1012

return RX_MGMT_NONE;

1013

}

1013

}

1014

1015

static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,

1015

static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,

1016

bool deauth)

1016

bool deauth)

1017

{

1017

{

1018

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1018

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1019

struct ieee80211_local *local = sdata->local;

1019

struct ieee80211_local *local = sdata->local;

1020

struct sta_info *sta;

1020

struct sta_info *sta;

1021

u32 changed = 0, config_changed = 0;

1021

u32 changed = 0, config_changed = 0;

1022

u8 bssid[ETH_ALEN];

1022

u8 bssid[ETH_ALEN];

1023

1024

ASSERT_MGD_MTX(ifmgd);

1024

ASSERT_MGD_MTX(ifmgd);

1025

1026

if (WARN_ON(!ifmgd->associated))

1026

if (WARN_ON(!ifmgd->associated))

1027

return;

1027

return;

1028

1029

memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);

1029

memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);

1030

1031

ifmgd->associated = NULL;

1031

ifmgd->associated = NULL;

1032

memset(ifmgd->bssid, 0, ETH_ALEN);

1032

memset(ifmgd->bssid, 0, ETH_ALEN);

1033

1034

if (deauth) {

1034

if (deauth) {

1035

kfree(ifmgd->old_associate_work);

1035

kfree(ifmgd->old_associate_work);

1036

ifmgd->old_associate_work = NULL;

1036

ifmgd->old_associate_work = NULL;

1037

} else {

1037

} else {

1038

struct ieee80211_mgd_work *wk = ifmgd->old_associate_work;

1038

struct ieee80211_mgd_work *wk = ifmgd->old_associate_work;

1039

1040

wk->state = IEEE80211_MGD_STATE_IDLE;

1040

wk->state = IEEE80211_MGD_STATE_IDLE;

1041

list_add(&wk->list, &ifmgd->work_list);

1041

list_add(&wk->list, &ifmgd->work_list);

1042

}

1042

}

1043

1044

/*

1044

/*

1045

* we need to commit the associated = NULL change because the

1045

* we need to commit the associated = NULL change because the

1046

* scan code uses that to determine whether this iface should

1046

* scan code uses that to determine whether this iface should

1047

* go to/wake up from powersave or not -- and could otherwise

1047

* go to/wake up from powersave or not -- and could otherwise

1048

* wake the queues erroneously.

1048

* wake the queues erroneously.

1049

*/

1049

*/

1050

smp_mb();

1050

smp_mb();

1051

1052

/*

1052

/*

1053

* Thus, we can only afterwards stop the queues -- to account

1053

* Thus, we can only afterwards stop the queues -- to account

1054

* for the case where another CPU is finishing a scan at this

1054

* for the case where another CPU is finishing a scan at this

1055

* time -- we don't want the scan code to enable queues.

1055

* time -- we don't want the scan code to enable queues.

1056

*/

1056

*/

1057

1058

netif_tx_stop_all_queues(sdata->dev);

1058

netif_tx_stop_all_queues(sdata->dev);

1059

netif_carrier_off(sdata->dev);

1059

netif_carrier_off(sdata->dev);

1060

1061

rcu_read_lock();

1061

rcu_read_lock();

1062

sta = sta_info_get(local, bssid);

1062

sta = sta_info_get(local, bssid);

1063

if (sta)

1063

if (sta)

1064

ieee80211_sta_tear_down_BA_sessions(sta);

1064

ieee80211_sta_tear_down_BA_sessions(sta);

1065

rcu_read_unlock();

1065

rcu_read_unlock();

1066

1067

changed |= ieee80211_reset_erp_info(sdata);

1067

changed |= ieee80211_reset_erp_info(sdata);

1068

1069

ieee80211_led_assoc(local, 0);

1069

ieee80211_led_assoc(local, 0);

1070

changed |= BSS_CHANGED_ASSOC;

1070

changed |= BSS_CHANGED_ASSOC;

1071

sdata->vif.bss_conf.assoc = false;

1071

sdata->vif.bss_conf.assoc = false;

1072

1073

ieee80211_set_wmm_default(sdata);

1073

ieee80211_set_wmm_default(sdata);

1074

1075

ieee80211_recalc_idle(local);

1075

ieee80211_recalc_idle(local);

1076

1077

/* channel(_type) changes are handled by ieee80211_hw_config */

1077

/* channel(_type) changes are handled by ieee80211_hw_config */

1078

local->oper_channel_type = NL80211_CHAN_NO_HT;

1078

local->oper_channel_type = NL80211_CHAN_NO_HT;

1079

1080

/* on the next assoc, re-program HT parameters */

1080

/* on the next assoc, re-program HT parameters */

1081

sdata->ht_opmode_valid = false;

1081

sdata->ht_opmode_valid = false;

1082

1083

local->power_constr_level = 0;

1083

local->power_constr_level = 0;

1084

1085

del_timer_sync(&local->dynamic_ps_timer);

1085

del_timer_sync(&local->dynamic_ps_timer);

1086

cancel_work_sync(&local->dynamic_ps_enable_work);

1086

cancel_work_sync(&local->dynamic_ps_enable_work);

1087

1088

if (local->hw.conf.flags & IEEE80211_CONF_PS) {

1088

if (local->hw.conf.flags & IEEE80211_CONF_PS) {

1089

local->hw.conf.flags &= ~IEEE80211_CONF_PS;

1089

local->hw.conf.flags &= ~IEEE80211_CONF_PS;

1090

config_changed |= IEEE80211_CONF_CHANGE_PS;

1090

config_changed |= IEEE80211_CONF_CHANGE_PS;

1091

}

1091

}

1092

1093

ieee80211_hw_config(local, config_changed);

1093

ieee80211_hw_config(local, config_changed);

1094

1095

/* And the BSSID changed -- not very interesting here */

1095

/* And the BSSID changed -- not very interesting here */

1096

changed |= BSS_CHANGED_BSSID;

1096

changed |= BSS_CHANGED_BSSID;

1097

ieee80211_bss_info_change_notify(sdata, changed);

1097

ieee80211_bss_info_change_notify(sdata, changed);

1098

1099

rcu_read_lock();

1099

rcu_read_lock();

1100

1101

sta = sta_info_get(local, bssid);

1101

sta = sta_info_get(local, bssid);

1102

if (!sta) {

1102

if (!sta) {

1103

rcu_read_unlock();

1103

rcu_read_unlock();

1104

return;

1104

return;

1105

}

1105

}

1106

1107

sta_info_unlink(&sta);

1107

sta_info_unlink(&sta);

1108

1109

rcu_read_unlock();

1109

rcu_read_unlock();

1110

1111

sta_info_destroy(sta);

1111

sta_info_destroy(sta);

1112

}

1112

}

1113

1114

static enum rx_mgmt_action __must_check

1114

static enum rx_mgmt_action __must_check

1115

ieee80211_associate(struct ieee80211_sub_if_data *sdata,

1115

ieee80211_associate(struct ieee80211_sub_if_data *sdata,

1116

struct ieee80211_mgd_work *wk)

1116

struct ieee80211_mgd_work *wk)

1117

{

1117

{

1118

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1118

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1119

struct ieee80211_local *local = sdata->local;

1119

struct ieee80211_local *local = sdata->local;

1120

1121

wk->tries++;

1121

wk->tries++;

1122

if (wk->tries > IEEE80211_ASSOC_MAX_TRIES) {

1122

if (wk->tries > IEEE80211_ASSOC_MAX_TRIES) {

1123

printk(KERN_DEBUG "%s: association with AP %pM"

1123

printk(KERN_DEBUG "%s: association with AP %pM"

1124

" timed out\n",

1124

" timed out\n",

1125

sdata->dev->name, wk->bss->cbss.bssid);

1125

sdata->dev->name, wk->bss->cbss.bssid);

1126

1127

/*

1127

/*

1128

* Most likely AP is not in the range so remove the

1128

* Most likely AP is not in the range so remove the

1129

* bss struct for that AP.

1129

* bss struct for that AP.

1130

*/

1130

*/

1131

cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);

1131

cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);

1132

1133

/*

1133

/*

1134

* We might have a pending scan which had no chance to run yet

1134

* We might have a pending scan which had no chance to run yet

1135

* due to work needing to be done. Hence, queue the STAs work

1135

* due to work needing to be done. Hence, queue the STAs work

1136

* again for that.

1136

* again for that.

1137

*/

1137

*/

1138

ieee80211_queue_work(&local->hw, &ifmgd->work);

1138

ieee80211_queue_work(&local->hw, &ifmgd->work);

1139

return RX_MGMT_CFG80211_ASSOC_TO;

1139

return RX_MGMT_CFG80211_ASSOC_TO;

1140

}

1140

}

1141

1142

printk(KERN_DEBUG "%s: associate with AP %pM (try %d)\n",

1142

printk(KERN_DEBUG "%s: associate with AP %pM (try %d)\n",

1143

sdata->dev->name, wk->bss->cbss.bssid, wk->tries);

1143

sdata->dev->name, wk->bss->cbss.bssid, wk->tries);

1144

ieee80211_send_assoc(sdata, wk);

1144

ieee80211_send_assoc(sdata, wk);

1145

1146

wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;

1146

wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;

1147

run_again(ifmgd, wk->timeout);

1147

run_again(ifmgd, wk->timeout);

1148

1149

return RX_MGMT_NONE;

1149

return RX_MGMT_NONE;

1150

}

1150

}

1151

1152

void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,

1152

void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,

1153

struct ieee80211_hdr *hdr)

1153

struct ieee80211_hdr *hdr)

1154

{

1154

{

1155

/*

1155

/*

1156

* We can postpone the mgd.timer whenever receiving unicast frames

1156

* We can postpone the mgd.timer whenever receiving unicast frames

1157

* from AP because we know that the connection is working both ways

1157

* from AP because we know that the connection is working both ways

1158

* at that time. But multicast frames (and hence also beacons) must

1158

* at that time. But multicast frames (and hence also beacons) must

1159

* be ignored here, because we need to trigger the timer during

1159

* be ignored here, because we need to trigger the timer during

1160

* data idle periods for sending the periodic probe request to the

1160

* data idle periods for sending the periodic probe request to the

1161

* AP we're connected to.

1161

* AP we're connected to.

1162

*/

1162

*/

1163

if (is_multicast_ether_addr(hdr->addr1))

1163

if (is_multicast_ether_addr(hdr->addr1))

1164

return;

1164

return;

1165

1166

mod_timer(&sdata->u.mgd.conn_mon_timer,

1166

mod_timer(&sdata->u.mgd.conn_mon_timer,

1167

round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));

1167

round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));

1168

}

1168

}

1169

1170

static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)

1170

static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)

1171

{

1171

{

1172

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1172

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1173

const u8 *ssid;

1173

const u8 *ssid;

1174

1175

ssid = ieee80211_bss_get_ie(&ifmgd->associated->cbss, WLAN_EID_SSID);

1175

ssid = ieee80211_bss_get_ie(&ifmgd->associated->cbss, WLAN_EID_SSID);

1176

ieee80211_send_probe_req(sdata, ifmgd->associated->cbss.bssid,

1176

ieee80211_send_probe_req(sdata, ifmgd->associated->cbss.bssid,

1177

ssid + 2, ssid[1], NULL, 0);

1177

ssid + 2, ssid[1], NULL, 0);

1178

1179

ifmgd->probe_send_count++;

1179

ifmgd->probe_send_count++;

1180

ifmgd->probe_timeout = jiffies + IEEE80211_PROBE_WAIT;

1180

ifmgd->probe_timeout = jiffies + IEEE80211_PROBE_WAIT;

1181

run_again(ifmgd, ifmgd->probe_timeout);

1181

run_again(ifmgd, ifmgd->probe_timeout);

1182

}

1182

}

1183

1184

static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,

1184

static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,

1185

bool beacon)

1185

bool beacon)

1186

{

1186

{

1187

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1187

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1188

bool already = false;

1188

bool already = false;

1189

1190

if (!netif_running(sdata->dev))

1190

if (!netif_running(sdata->dev))

1191

return;

1191

return;

1192

1193

if (sdata->local->scanning)

1193

if (sdata->local->scanning)

1194

return;

1194

return;

1195

1196

mutex_lock(&ifmgd->mtx);

1196

mutex_lock(&ifmgd->mtx);

1197

1198

if (!ifmgd->associated)

1198

if (!ifmgd->associated)

1199

goto out;

1199

goto out;

1200

1201

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1201

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1202

if (beacon && net_ratelimit())

1202

if (beacon && net_ratelimit())

1203

printk(KERN_DEBUG "%s: detected beacon loss from AP "

1203

printk(KERN_DEBUG "%s: detected beacon loss from AP "

1204

"- sending probe request\n", sdata->dev->name);

1204

"- sending probe request\n", sdata->dev->name);

1205

#endif

1205

#endif

1206

1207

/*

1207

/*

1208

* The driver/our work has already reported this event or the

1208

* The driver/our work has already reported this event or the

1209

* connection monitoring has kicked in and we have already sent

1209

* connection monitoring has kicked in and we have already sent

1210

* a probe request. Or maybe the AP died and the driver keeps

1210

* a probe request. Or maybe the AP died and the driver keeps

1211

* reporting until we disassociate...

1211

* reporting until we disassociate...

1212

*

1212

*

1213

* In either case we have to ignore the current call to this

1213

* In either case we have to ignore the current call to this

1214

* function (except for setting the correct probe reason bit)

1214

* function (except for setting the correct probe reason bit)

1215

* because otherwise we would reset the timer every time and

1215

* because otherwise we would reset the timer every time and

1216

* never check whether we received a probe response!

1216

* never check whether we received a probe response!

1217

*/

1217

*/

1218

if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |

1218

if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |

1219

IEEE80211_STA_CONNECTION_POLL))

1219

IEEE80211_STA_CONNECTION_POLL))

1220

already = true;

1220

already = true;

1221

1222

if (beacon)

1222

if (beacon)

1223

ifmgd->flags |= IEEE80211_STA_BEACON_POLL;

1223

ifmgd->flags |= IEEE80211_STA_BEACON_POLL;

1224

else

1224

else

1225

ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;

1225

ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;

1226

1227

if (already)

1227

if (already)

1228

goto out;

1228

goto out;

1229

1230

mutex_lock(&sdata->local->iflist_mtx);

1230

mutex_lock(&sdata->local->iflist_mtx);

1231

ieee80211_recalc_ps(sdata->local, -1);

1231

ieee80211_recalc_ps(sdata->local, -1);

1232

mutex_unlock(&sdata->local->iflist_mtx);

1232

mutex_unlock(&sdata->local->iflist_mtx);

1233

1234

ifmgd->probe_send_count = 0;

1234

ifmgd->probe_send_count = 0;

1235

ieee80211_mgd_probe_ap_send(sdata);

1235

ieee80211_mgd_probe_ap_send(sdata);

1236

out:

1236

out:

1237

mutex_unlock(&ifmgd->mtx);

1237

mutex_unlock(&ifmgd->mtx);

1238

}

1238

}

1239

1240

void ieee80211_beacon_loss_work(struct work_struct *work)

1240

void ieee80211_beacon_loss_work(struct work_struct *work)

1241

{

1241

{

1242

struct ieee80211_sub_if_data *sdata =

1242

struct ieee80211_sub_if_data *sdata =

1243

container_of(work, struct ieee80211_sub_if_data,

1243

container_of(work, struct ieee80211_sub_if_data,

1244

u.mgd.beacon_loss_work);

1244

u.mgd.beacon_loss_work);

1245

1246

ieee80211_mgd_probe_ap(sdata, true);

1246

ieee80211_mgd_probe_ap(sdata, true);

1247

}

1247

}

1248

1249

void ieee80211_beacon_loss(struct ieee80211_vif *vif)

1249

void ieee80211_beacon_loss(struct ieee80211_vif *vif)

1250

{

1250

{

1251

struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);

1251

struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);

1252

1253

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);

1253

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);

1254

}

1254

}

1255

EXPORT_SYMBOL(ieee80211_beacon_loss);

1255

EXPORT_SYMBOL(ieee80211_beacon_loss);

1256

1257

static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata,

1257

static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata,

1258

struct ieee80211_mgd_work *wk)

1258

struct ieee80211_mgd_work *wk)

1259

{

1259

{

1260

wk->state = IEEE80211_MGD_STATE_IDLE;

1260

wk->state = IEEE80211_MGD_STATE_IDLE;

1261

printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);

1261

printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);

1262

}

1262

}

1263

1264

1265

static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,

1265

static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,

1266

struct ieee80211_mgd_work *wk,

1266

struct ieee80211_mgd_work *wk,

1267

struct ieee80211_mgmt *mgmt,

1267

struct ieee80211_mgmt *mgmt,

1268

size_t len)

1268

size_t len)

1269

{

1269

{

1270

u8 *pos;

1270

u8 *pos;

1271

struct ieee802_11_elems elems;

1271

struct ieee802_11_elems elems;

1272

1273

pos = mgmt->u.auth.variable;

1273

pos = mgmt->u.auth.variable;

1274

ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);

1274

ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);

1275

if (!elems.challenge)

1275

if (!elems.challenge)

1276

return;

1276

return;

1277

ieee80211_send_auth(sdata, 3, wk->auth_alg,

1277

ieee80211_send_auth(sdata, 3, wk->auth_alg,

1278

elems.challenge - 2, elems.challenge_len + 2,

1278

elems.challenge - 2, elems.challenge_len + 2,

1279

wk->bss->cbss.bssid,

1279

wk->bss->cbss.bssid,

1280

wk->key, wk->key_len, wk->key_idx);

1280

wk->key, wk->key_len, wk->key_idx);

1281

wk->auth_transaction = 4;

1281

wk->auth_transaction = 4;

1282

}

1282

}

1283

1284

static enum rx_mgmt_action __must_check

1284

static enum rx_mgmt_action __must_check

1285

ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,

1285

ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,

1286

struct ieee80211_mgd_work *wk,

1286

struct ieee80211_mgd_work *wk,

1287

struct ieee80211_mgmt *mgmt, size_t len)

1287

struct ieee80211_mgmt *mgmt, size_t len)

1288

{

1288

{

1289

u16 auth_alg, auth_transaction, status_code;

1289

u16 auth_alg, auth_transaction, status_code;

1290

1291

if (wk->state != IEEE80211_MGD_STATE_AUTH)

1291

if (wk->state != IEEE80211_MGD_STATE_AUTH)

1292

return RX_MGMT_NONE;

1292

return RX_MGMT_NONE;

1293

1294

if (len < 24 + 6)

1294

if (len < 24 + 6)

1295

return RX_MGMT_NONE;

1295

return RX_MGMT_NONE;

1296

1297

if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)

1297

if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)

1298

return RX_MGMT_NONE;

1298

return RX_MGMT_NONE;

1299

1300

if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)

1300

if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)

1301

return RX_MGMT_NONE;

1301

return RX_MGMT_NONE;

1302

1303

auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);

1303

auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);

1304

auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);

1304

auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);

1305

status_code = le16_to_cpu(mgmt->u.auth.status_code);

1305

status_code = le16_to_cpu(mgmt->u.auth.status_code);

1306

1307

if (auth_alg != wk->auth_alg ||

1307

if (auth_alg != wk->auth_alg ||

1308

auth_transaction != wk->auth_transaction)

1308

auth_transaction != wk->auth_transaction)

1309

return RX_MGMT_NONE;

1309

return RX_MGMT_NONE;

1310

1311

if (status_code != WLAN_STATUS_SUCCESS) {

1311

if (status_code != WLAN_STATUS_SUCCESS) {

1312

list_del(&wk->list);

1312

list_del(&wk->list);

1313

kfree(wk);

1313

kfree(wk);

1314

return RX_MGMT_CFG80211_AUTH;

1314

return RX_MGMT_CFG80211_AUTH;

1315

}

1315

}

1316

1317

switch (wk->auth_alg) {

1317

switch (wk->auth_alg) {

1318

case WLAN_AUTH_OPEN:

1318

case WLAN_AUTH_OPEN:

1319

case WLAN_AUTH_LEAP:

1319

case WLAN_AUTH_LEAP:

1320

case WLAN_AUTH_FT:

1320

case WLAN_AUTH_FT:

1321

ieee80211_auth_completed(sdata, wk);

1321

ieee80211_auth_completed(sdata, wk);

1322

return RX_MGMT_CFG80211_AUTH;

1322

return RX_MGMT_CFG80211_AUTH;

1323

case WLAN_AUTH_SHARED_KEY:

1323

case WLAN_AUTH_SHARED_KEY:

1324

if (wk->auth_transaction == 4) {

1324

if (wk->auth_transaction == 4) {

1325

ieee80211_auth_completed(sdata, wk);

1325

ieee80211_auth_completed(sdata, wk);

1326

return RX_MGMT_CFG80211_AUTH;

1326

return RX_MGMT_CFG80211_AUTH;

1327

} else

1327

} else

1328

ieee80211_auth_challenge(sdata, wk, mgmt, len);

1328

ieee80211_auth_challenge(sdata, wk, mgmt, len);

1329

break;

1329

break;

1330

}

1330

}

1331

1332

return RX_MGMT_NONE;

1332

return RX_MGMT_NONE;

1333

}

1333

}

1334

1335

1336

static enum rx_mgmt_action __must_check

1336

static enum rx_mgmt_action __must_check

1337

ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,

1337

ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,

1338

struct ieee80211_mgd_work *wk,

1338

struct ieee80211_mgd_work *wk,

1339

struct ieee80211_mgmt *mgmt, size_t len)

1339

struct ieee80211_mgmt *mgmt, size_t len)

1340

{

1340

{

1341

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1341

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1342

const u8 *bssid = NULL;

1342

const u8 *bssid = NULL;

1343

u16 reason_code;

1343

u16 reason_code;

1344

1345

if (len < 24 + 2)

1345

if (len < 24 + 2)

1346

return RX_MGMT_NONE;

1346

return RX_MGMT_NONE;

1347

1348

ASSERT_MGD_MTX(ifmgd);

1348

ASSERT_MGD_MTX(ifmgd);

1349

1350

if (wk)

1350

if (wk)

1351

bssid = wk->bss->cbss.bssid;

1351

bssid = wk->bss->cbss.bssid;

1352

else

1352

else

1353

bssid = ifmgd->associated->cbss.bssid;

1353

bssid = ifmgd->associated->cbss.bssid;

1354

1355

reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);

1355

reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);

1356

1357

printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",

1357

printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",

1358

sdata->dev->name, bssid, reason_code);

1358

sdata->dev->name, bssid, reason_code);

1359

1360

if (!wk) {

1360

if (!wk) {

1361

ieee80211_set_disassoc(sdata, true);

1361

ieee80211_set_disassoc(sdata, true);

1362

} else {

1362

} else {

1363

list_del(&wk->list);

1363

list_del(&wk->list);

1364

kfree(wk);

1364

kfree(wk);

1365

}

1365

}

1366

1367

return RX_MGMT_CFG80211_DEAUTH;

1367

return RX_MGMT_CFG80211_DEAUTH;

1368

}

1368

}

1369

1370

1371

static enum rx_mgmt_action __must_check

1371

static enum rx_mgmt_action __must_check

1372

ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,

1372

ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,

1373

struct ieee80211_mgmt *mgmt, size_t len)

1373

struct ieee80211_mgmt *mgmt, size_t len)

1374

{

1374

{

1375

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1375

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1376

u16 reason_code;

1376

u16 reason_code;

1377

1378

if (len < 24 + 2)

1378

if (len < 24 + 2)

1379

return RX_MGMT_NONE;

1379

return RX_MGMT_NONE;

1380

1381

ASSERT_MGD_MTX(ifmgd);

1381

ASSERT_MGD_MTX(ifmgd);

1382

1383

if (WARN_ON(!ifmgd->associated))

1383

if (WARN_ON(!ifmgd->associated))

1384

return RX_MGMT_NONE;

1384

return RX_MGMT_NONE;

1385

1386

if (WARN_ON(memcmp(ifmgd->associated->cbss.bssid, mgmt->sa, ETH_ALEN)))

1386

if (WARN_ON(memcmp(ifmgd->associated->cbss.bssid, mgmt->sa, ETH_ALEN)))

1387

return RX_MGMT_NONE;

1387

return RX_MGMT_NONE;

1388

1389

reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);

1389

reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);

1390

1391

printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",

1391

printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",

1392

sdata->dev->name, mgmt->sa, reason_code);

1392

sdata->dev->name, mgmt->sa, reason_code);

1393

1394

ieee80211_set_disassoc(sdata, false);

1394

ieee80211_set_disassoc(sdata, false);

1395

return RX_MGMT_CFG80211_DISASSOC;

1395

return RX_MGMT_CFG80211_DISASSOC;

1396

}

1396

}

1397

1398

1399

static enum rx_mgmt_action __must_check

1399

static enum rx_mgmt_action __must_check

1400

ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,

1400

ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,

1401

struct ieee80211_mgd_work *wk,

1401

struct ieee80211_mgd_work *wk,

1402

struct ieee80211_mgmt *mgmt, size_t len,

1402

struct ieee80211_mgmt *mgmt, size_t len,

1403

bool reassoc)

1403

bool reassoc)

1404

{

1404

{

1405

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1405

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1406

struct ieee80211_local *local = sdata->local;

1406

struct ieee80211_local *local = sdata->local;

1407

struct ieee80211_supported_band *sband;

1407

struct ieee80211_supported_band *sband;

1408

struct sta_info *sta;

1408

struct sta_info *sta;

1409

u32 rates, basic_rates;

1409

u32 rates, basic_rates;

1410

u16 capab_info, status_code, aid;

1410

u16 capab_info, status_code, aid;

1411

struct ieee802_11_elems elems;

1411

struct ieee802_11_elems elems;

1412

struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;

1412

struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;

1413

u8 *pos;

1413

u8 *pos;

1414

u32 changed = 0;

1414

u32 changed = 0;

1415

int i, j;

1415

int i, j;

1416

bool have_higher_than_11mbit = false, newsta = false;

1416

bool have_higher_than_11mbit = false, newsta = false;

1417

u16 ap_ht_cap_flags;

1417

u16 ap_ht_cap_flags;

1418

1419

/*

1419

/*

1420

* AssocResp and ReassocResp have identical structure, so process both

1420

* AssocResp and ReassocResp have identical structure, so process both

1421

* of them in this function.

1421

* of them in this function.

1422

*/

1422

*/

1423

1424

if (len < 24 + 6)

1424

if (len < 24 + 6)

1425

return RX_MGMT_NONE;

1425

return RX_MGMT_NONE;

1426

1427

if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)

1427

if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)

1428

return RX_MGMT_NONE;

1428

return RX_MGMT_NONE;

1429

1430

capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);

1430

capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);

1431

status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);

1431

status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);

1432

aid = le16_to_cpu(mgmt->u.assoc_resp.aid);

1432

aid = le16_to_cpu(mgmt->u.assoc_resp.aid);

1433

1434

printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "

1434

printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "

1435

"status=%d aid=%d)\n",

1435

"status=%d aid=%d)\n",

1436

sdata->dev->name, reassoc ? "Rea" : "A", mgmt->sa,

1436

sdata->dev->name, reassoc ? "Rea" : "A", mgmt->sa,

1437

capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));

1437

capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));

1438

1439

pos = mgmt->u.assoc_resp.variable;

1439

pos = mgmt->u.assoc_resp.variable;

1440

ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);

1440

ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);

1441

1442

if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&

1442

if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&

1443

elems.timeout_int && elems.timeout_int_len == 5 &&

1443

elems.timeout_int && elems.timeout_int_len == 5 &&

1444

elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {

1444

elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {

1445

u32 tu, ms;

1445

u32 tu, ms;

1446

tu = get_unaligned_le32(elems.timeout_int + 1);

1446

tu = get_unaligned_le32(elems.timeout_int + 1);

1447

ms = tu * 1024 / 1000;

1447

ms = tu * 1024 / 1000;

1448

printk(KERN_DEBUG "%s: AP rejected association temporarily; "

1448

printk(KERN_DEBUG "%s: AP rejected association temporarily; "

1449

"comeback duration %u TU (%u ms)\n",

1449

"comeback duration %u TU (%u ms)\n",

1450

sdata->dev->name, tu, ms);

1450

sdata->dev->name, tu, ms);

1451

wk->timeout = jiffies + msecs_to_jiffies(ms);

1451

wk->timeout = jiffies + msecs_to_jiffies(ms);

1452

if (ms > IEEE80211_ASSOC_TIMEOUT)

1452

if (ms > IEEE80211_ASSOC_TIMEOUT)

1453

run_again(ifmgd, jiffies + msecs_to_jiffies(ms));

1453

run_again(ifmgd, jiffies + msecs_to_jiffies(ms));

1454

return RX_MGMT_NONE;

1454

return RX_MGMT_NONE;

1455

}

1455

}

1456

1457

if (status_code != WLAN_STATUS_SUCCESS) {

1457

if (status_code != WLAN_STATUS_SUCCESS) {

1458

printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",

1458

printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",

1459

sdata->dev->name, status_code);

1459

sdata->dev->name, status_code);

1460

list_del(&wk->list);

1460

wk->state = IEEE80211_MGD_STATE_IDLE;

1461

kfree(wk);

1462

return RX_MGMT_CFG80211_ASSOC;

1461

return RX_MGMT_CFG80211_ASSOC;

1463

}

1462

}

1464

1463

1465

if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))

1464

if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))

1466

printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "

1465

printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "

1467

"set\n", sdata->dev->name, aid);

1466

"set\n", sdata->dev->name, aid);

1468

aid &= ~(BIT(15) | BIT(14));

1467

aid &= ~(BIT(15) | BIT(14));

1469

1468

1470

if (!elems.supp_rates) {

1469

if (!elems.supp_rates) {

1471

printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",

1470

printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",

1472

sdata->dev->name);

1471

sdata->dev->name);

1473

return RX_MGMT_NONE;

1472

return RX_MGMT_NONE;

1474

}

1473

}

1475

1474

1476

printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);

1475

printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);

1477

ifmgd->aid = aid;

1476

ifmgd->aid = aid;

1478

1477

1479

rcu_read_lock();

1478

rcu_read_lock();

1480

1479

1481

/* Add STA entry for the AP */

1480

/* Add STA entry for the AP */

1482

sta = sta_info_get(local, wk->bss->cbss.bssid);

1481

sta = sta_info_get(local, wk->bss->cbss.bssid);

1483

if (!sta) {

1482

if (!sta) {

1484

newsta = true;

1483

newsta = true;

1485

1484

1486

rcu_read_unlock();

1485

rcu_read_unlock();

1487

1486

1488

sta = sta_info_alloc(sdata, wk->bss->cbss.bssid, GFP_KERNEL);

1487

sta = sta_info_alloc(sdata, wk->bss->cbss.bssid, GFP_KERNEL);

1489

if (!sta) {

1488

if (!sta) {

1490

printk(KERN_DEBUG "%s: failed to alloc STA entry for"

1489

printk(KERN_DEBUG "%s: failed to alloc STA entry for"

1491

" the AP\n", sdata->dev->name);

1490

" the AP\n", sdata->dev->name);

1492

return RX_MGMT_NONE;

1491

return RX_MGMT_NONE;

1493

}

1492

}

1494

1493

1495

set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC |

1494

set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC |

1496

WLAN_STA_ASSOC_AP);

1495

WLAN_STA_ASSOC_AP);

1497

if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))

1496

if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))

1498

set_sta_flags(sta, WLAN_STA_AUTHORIZED);

1497

set_sta_flags(sta, WLAN_STA_AUTHORIZED);

1499

1498

1500

rcu_read_lock();

1499

rcu_read_lock();

1501

}

1500

}

1502

1501

1503

rates = 0;

1502

rates = 0;

1504

basic_rates = 0;

1503

basic_rates = 0;

1505

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

1504

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

1506

1505

1507

for (i = 0; i < elems.supp_rates_len; i++) {

1506

for (i = 0; i < elems.supp_rates_len; i++) {

1508

int rate = (elems.supp_rates[i] & 0x7f) * 5;

1507

int rate = (elems.supp_rates[i] & 0x7f) * 5;

1509

bool is_basic = !!(elems.supp_rates[i] & 0x80);

1508

bool is_basic = !!(elems.supp_rates[i] & 0x80);

1510

1509

1511

if (rate > 110)

1510

if (rate > 110)

1512

have_higher_than_11mbit = true;

1511

have_higher_than_11mbit = true;

1513

1512

1514

for (j = 0; j < sband->n_bitrates; j++) {

1513

for (j = 0; j < sband->n_bitrates; j++) {

1515

if (sband->bitrates[j].bitrate == rate) {

1514

if (sband->bitrates[j].bitrate == rate) {

1516

rates |= BIT(j);

1515

rates |= BIT(j);

1517

if (is_basic)

1516

if (is_basic)

1518

basic_rates |= BIT(j);

1517

basic_rates |= BIT(j);

1519

break;

1518

break;

1520

}

1519

}

1521

}

1520

}

1522

}

1521

}

1523

1522

1524

for (i = 0; i < elems.ext_supp_rates_len; i++) {

1523

for (i = 0; i < elems.ext_supp_rates_len; i++) {

1525

int rate = (elems.ext_supp_rates[i] & 0x7f) * 5;

1524

int rate = (elems.ext_supp_rates[i] & 0x7f) * 5;

1526

bool is_basic = !!(elems.ext_supp_rates[i] & 0x80);

1525

bool is_basic = !!(elems.ext_supp_rates[i] & 0x80);

1527

1526

1528

if (rate > 110)

1527

if (rate > 110)

1529

have_higher_than_11mbit = true;

1528

have_higher_than_11mbit = true;

1530

1529

1531

for (j = 0; j < sband->n_bitrates; j++) {

1530

for (j = 0; j < sband->n_bitrates; j++) {

1532

if (sband->bitrates[j].bitrate == rate) {

1531

if (sband->bitrates[j].bitrate == rate) {

1533

rates |= BIT(j);

1532

rates |= BIT(j);

1534

if (is_basic)

1533

if (is_basic)

1535

basic_rates |= BIT(j);

1534

basic_rates |= BIT(j);

1536

break;

1535

break;

1537

}

1536

}

1538

}

1537

}

1539

}

1538

}

1540

1539

1541

sta->sta.supp_rates[local->hw.conf.channel->band] = rates;

1540

sta->sta.supp_rates[local->hw.conf.channel->band] = rates;

1542

sdata->vif.bss_conf.basic_rates = basic_rates;

1541

sdata->vif.bss_conf.basic_rates = basic_rates;

1543

1542

1544

/* cf. IEEE 802.11 9.2.12 */

1543

/* cf. IEEE 802.11 9.2.12 */

1545

if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&

1544

if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&

1546

have_higher_than_11mbit)

1545

have_higher_than_11mbit)

1547

sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;

1546

sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;

1548

else

1547

else

1549

sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;

1548

sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;

1550

1549

1551

if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))

1550

if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))

1552

ieee80211_ht_cap_ie_to_sta_ht_cap(sband,

1551

ieee80211_ht_cap_ie_to_sta_ht_cap(sband,

1553

elems.ht_cap_elem, &sta->sta.ht_cap);

1552

elems.ht_cap_elem, &sta->sta.ht_cap);

1554

1553

1555

ap_ht_cap_flags = sta->sta.ht_cap.cap;

1554

ap_ht_cap_flags = sta->sta.ht_cap.cap;

1556

1555

1557

rate_control_rate_init(sta);

1556

rate_control_rate_init(sta);

1558

1557

1559

if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)

1558

if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)

1560

set_sta_flags(sta, WLAN_STA_MFP);

1559

set_sta_flags(sta, WLAN_STA_MFP);

1561

1560

1562

if (elems.wmm_param)

1561

if (elems.wmm_param)

1563

set_sta_flags(sta, WLAN_STA_WME);

1562

set_sta_flags(sta, WLAN_STA_WME);

1564

1563

1565

if (newsta) {

1564

if (newsta) {

1566

int err = sta_info_insert(sta);

1565

int err = sta_info_insert(sta);

1567

if (err) {

1566

if (err) {

1568

printk(KERN_DEBUG "%s: failed to insert STA entry for"

1567

printk(KERN_DEBUG "%s: failed to insert STA entry for"

1569

" the AP (error %d)\n", sdata->dev->name, err);

1568

" the AP (error %d)\n", sdata->dev->name, err);

1570

rcu_read_unlock();

1569

rcu_read_unlock();

1571

return RX_MGMT_NONE;

1570

return RX_MGMT_NONE;

1572

}

1571

}

1573

}

1572

}

1574

1573

1575

rcu_read_unlock();

1574

rcu_read_unlock();

1576

1575

1577

if (elems.wmm_param)

1576

if (elems.wmm_param)

1578

ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,

1577

ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,

1579

elems.wmm_param_len);

1578

elems.wmm_param_len);

1580

else

1579

else

1581

ieee80211_set_wmm_default(sdata);

1580

ieee80211_set_wmm_default(sdata);

1582

1581

1583

if (elems.ht_info_elem && elems.wmm_param &&

1582

if (elems.ht_info_elem && elems.wmm_param &&

1584

(ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&

1583

(ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&

1585

!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))

1584

!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))

1586

changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,

1585

changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,

1587

wk->bss->cbss.bssid,

1586

wk->bss->cbss.bssid,

1588

ap_ht_cap_flags);

1587

ap_ht_cap_flags);

1589

1588

1590

/* delete work item -- must be before set_associated for PS */

1589

/* delete work item -- must be before set_associated for PS */

1591

list_del(&wk->list);

1590

list_del(&wk->list);

1592

1591

1593

/* set AID and assoc capability,

1592

/* set AID and assoc capability,

1594

* ieee80211_set_associated() will tell the driver */

1593

* ieee80211_set_associated() will tell the driver */

1595

bss_conf->aid = aid;

1594

bss_conf->aid = aid;

1596

bss_conf->assoc_capability = capab_info;

1595

bss_conf->assoc_capability = capab_info;

1597

/* this will take ownership of wk */

1596

/* this will take ownership of wk */

1598

ieee80211_set_associated(sdata, wk, changed);

1597

ieee80211_set_associated(sdata, wk, changed);

1599

1598

1600

/*

1599

/*

1601

* Start timer to probe the connection to the AP now.

1600

* Start timer to probe the connection to the AP now.

1602

* Also start the timer that will detect beacon loss.

1601

* Also start the timer that will detect beacon loss.

1603

*/

1602

*/

1604

ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);

1603

ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);

1605

mod_beacon_timer(sdata);

1604

mod_beacon_timer(sdata);

1606

1605

1607

return RX_MGMT_CFG80211_ASSOC;

1606

return RX_MGMT_CFG80211_ASSOC;

1608

}

1607

}

1609

1608

1610

1609

1611

static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,

1610

static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,

1612

struct ieee80211_mgmt *mgmt,

1611

struct ieee80211_mgmt *mgmt,

1613

size_t len,

1612

size_t len,

1614

struct ieee80211_rx_status *rx_status,

1613

struct ieee80211_rx_status *rx_status,

1615

struct ieee802_11_elems *elems,

1614

struct ieee802_11_elems *elems,

1616

bool beacon)

1615

bool beacon)

1617

{

1616

{

1618

struct ieee80211_local *local = sdata->local;

1617

struct ieee80211_local *local = sdata->local;

1619

int freq;

1618

int freq;

1620

struct ieee80211_bss *bss;

1619

struct ieee80211_bss *bss;

1621

struct ieee80211_channel *channel;

1620

struct ieee80211_channel *channel;

1622

1621

1623

if (elems->ds_params && elems->ds_params_len == 1)

1622

if (elems->ds_params && elems->ds_params_len == 1)

1624

freq = ieee80211_channel_to_frequency(elems->ds_params[0]);

1623

freq = ieee80211_channel_to_frequency(elems->ds_params[0]);

1625

else

1624

else

1626

freq = rx_status->freq;

1625

freq = rx_status->freq;

1627

1626

1628

channel = ieee80211_get_channel(local->hw.wiphy, freq);

1627

channel = ieee80211_get_channel(local->hw.wiphy, freq);

1629

1628

1630

if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)

1629

if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)

1631

return;

1630

return;

1632

1631

1633

bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,

1632

bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,

1634

channel, beacon);

1633

channel, beacon);

1635

if (bss)

1634

if (bss)

1636

ieee80211_rx_bss_put(local, bss);

1635

ieee80211_rx_bss_put(local, bss);

1637

1636

1638

if (!sdata->u.mgd.associated)

1637

if (!sdata->u.mgd.associated)

1639

return;

1638

return;

1640

1639

1641

if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&

1640

if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&

1642

(memcmp(mgmt->bssid, sdata->u.mgd.associated->cbss.bssid,

1641

(memcmp(mgmt->bssid, sdata->u.mgd.associated->cbss.bssid,

1643

ETH_ALEN) == 0)) {

1642

ETH_ALEN) == 0)) {

1644

struct ieee80211_channel_sw_ie *sw_elem =

1643

struct ieee80211_channel_sw_ie *sw_elem =

1645

(struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;

1644

(struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;

1646

ieee80211_sta_process_chanswitch(sdata, sw_elem, bss);

1645

ieee80211_sta_process_chanswitch(sdata, sw_elem, bss);

1647

}

1646

}

1648

}

1647

}

1649

1648

1650

1649

1651

static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,

1650

static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,

1652

struct ieee80211_mgd_work *wk,

1651

struct ieee80211_mgd_work *wk,

1653

struct ieee80211_mgmt *mgmt, size_t len,

1652

struct ieee80211_mgmt *mgmt, size_t len,

1654

struct ieee80211_rx_status *rx_status)

1653

struct ieee80211_rx_status *rx_status)

1655

{

1654

{

1656

struct ieee80211_if_managed *ifmgd;

1655

struct ieee80211_if_managed *ifmgd;

1657

size_t baselen;

1656

size_t baselen;

1658

struct ieee802_11_elems elems;

1657

struct ieee802_11_elems elems;

1659

1658

1660

ifmgd = &sdata->u.mgd;

1659

ifmgd = &sdata->u.mgd;

1661

1660

1662

ASSERT_MGD_MTX(ifmgd);

1661

ASSERT_MGD_MTX(ifmgd);

1663

1662

1664

if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))

1663

if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))

1665

return; /* ignore ProbeResp to foreign address */

1664

return; /* ignore ProbeResp to foreign address */

1666

1665

1667

baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;

1666

baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;

1668

if (baselen > len)

1667

if (baselen > len)

1669

return;

1668

return;

1670

1669

1671

ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,

1670

ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,

1672

&elems);

1671

&elems);

1673

1672

1674

ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);

1673

ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);

1675

1674

1676

/* direct probe may be part of the association flow */

1675

/* direct probe may be part of the association flow */

1677

if (wk && wk->state == IEEE80211_MGD_STATE_PROBE) {

1676

if (wk && wk->state == IEEE80211_MGD_STATE_PROBE) {

1678

printk(KERN_DEBUG "%s: direct probe responded\n",

1677

printk(KERN_DEBUG "%s: direct probe responded\n",

1679

sdata->dev->name);

1678

sdata->dev->name);

1680

wk->tries = 0;

1679

wk->tries = 0;

1681

wk->state = IEEE80211_MGD_STATE_AUTH;

1680

wk->state = IEEE80211_MGD_STATE_AUTH;

1682

WARN_ON(ieee80211_authenticate(sdata, wk) != RX_MGMT_NONE);

1681

WARN_ON(ieee80211_authenticate(sdata, wk) != RX_MGMT_NONE);

1683

}

1682

}

1684

1683

1685

if (ifmgd->associated &&

1684

if (ifmgd->associated &&

1686

memcmp(mgmt->bssid, ifmgd->associated->cbss.bssid, ETH_ALEN) == 0 &&

1685

memcmp(mgmt->bssid, ifmgd->associated->cbss.bssid, ETH_ALEN) == 0 &&

1687

ifmgd->flags & (IEEE80211_STA_BEACON_POLL |

1686

ifmgd->flags & (IEEE80211_STA_BEACON_POLL |

1688

IEEE80211_STA_CONNECTION_POLL)) {

1687

IEEE80211_STA_CONNECTION_POLL)) {

1689

ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |

1688

ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |

1690

IEEE80211_STA_BEACON_POLL);

1689

IEEE80211_STA_BEACON_POLL);

1691

mutex_lock(&sdata->local->iflist_mtx);

1690

mutex_lock(&sdata->local->iflist_mtx);

1692

ieee80211_recalc_ps(sdata->local, -1);

1691

ieee80211_recalc_ps(sdata->local, -1);

1693

mutex_unlock(&sdata->local->iflist_mtx);

1692

mutex_unlock(&sdata->local->iflist_mtx);

1694

/*

1693

/*

1695

* We've received a probe response, but are not sure whether

1694

* We've received a probe response, but are not sure whether

1696

* we have or will be receiving any beacons or data, so let's

1695

* we have or will be receiving any beacons or data, so let's

1697

* schedule the timers again, just in case.

1696

* schedule the timers again, just in case.

1698

*/

1697

*/

1699

mod_beacon_timer(sdata);

1698

mod_beacon_timer(sdata);

1700

mod_timer(&ifmgd->conn_mon_timer,

1699

mod_timer(&ifmgd->conn_mon_timer,

1701

round_jiffies_up(jiffies +

1700

round_jiffies_up(jiffies +

1702

IEEE80211_CONNECTION_IDLE_TIME));

1701

IEEE80211_CONNECTION_IDLE_TIME));

1703

}

1702

}

1704

}

1703

}

1705

1704

1706

/*

1705

/*

1707

* This is the canonical list of information elements we care about,

1706

* This is the canonical list of information elements we care about,

1708

* the filter code also gives us all changes to the Microsoft OUI

1707

* the filter code also gives us all changes to the Microsoft OUI

1709

* (00:50:F2) vendor IE which is used for WMM which we need to track.

1708

* (00:50:F2) vendor IE which is used for WMM which we need to track.

1710

*

1709

*

1711

* We implement beacon filtering in software since that means we can

1710

* We implement beacon filtering in software since that means we can

1712

* avoid processing the frame here and in cfg80211, and userspace

1711

* avoid processing the frame here and in cfg80211, and userspace

1713

* will not be able to tell whether the hardware supports it or not.

1712

* will not be able to tell whether the hardware supports it or not.

1714

*

1713

*

1715

* XXX: This list needs to be dynamic -- userspace needs to be able to

1714

* XXX: This list needs to be dynamic -- userspace needs to be able to

1716

* add items it requires. It also needs to be able to tell us to

1715

* add items it requires. It also needs to be able to tell us to

1717

* look out for other vendor IEs.

1716

* look out for other vendor IEs.

1718

*/

1717

*/

1719

static const u64 care_about_ies =

1718

static const u64 care_about_ies =

1720

(1ULL << WLAN_EID_COUNTRY) |

1719

(1ULL << WLAN_EID_COUNTRY) |

1721

(1ULL << WLAN_EID_ERP_INFO) |

1720

(1ULL << WLAN_EID_ERP_INFO) |

1722

(1ULL << WLAN_EID_CHANNEL_SWITCH) |

1721

(1ULL << WLAN_EID_CHANNEL_SWITCH) |

1723

(1ULL << WLAN_EID_PWR_CONSTRAINT) |

1722

(1ULL << WLAN_EID_PWR_CONSTRAINT) |

1724

(1ULL << WLAN_EID_HT_CAPABILITY) |

1723

(1ULL << WLAN_EID_HT_CAPABILITY) |

1725

(1ULL << WLAN_EID_HT_INFORMATION);

1724

(1ULL << WLAN_EID_HT_INFORMATION);

1726

1725

1727

static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,

1726

static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,

1728

struct ieee80211_mgmt *mgmt,

1727

struct ieee80211_mgmt *mgmt,

1729

size_t len,

1728

size_t len,

1730

struct ieee80211_rx_status *rx_status)

1729

struct ieee80211_rx_status *rx_status)

1731

{

1730

{

1732

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1731

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1733

size_t baselen;

1732

size_t baselen;

1734

struct ieee802_11_elems elems;

1733

struct ieee802_11_elems elems;

1735

struct ieee80211_local *local = sdata->local;

1734

struct ieee80211_local *local = sdata->local;

1736

u32 changed = 0;

1735

u32 changed = 0;

1737

bool erp_valid, directed_tim = false;

1736

bool erp_valid, directed_tim = false;

1738

u8 erp_value = 0;

1737

u8 erp_value = 0;

1739

u32 ncrc;

1738

u32 ncrc;

1740

u8 *bssid;

1739

u8 *bssid;

1741

1740

1742

ASSERT_MGD_MTX(ifmgd);

1741

ASSERT_MGD_MTX(ifmgd);

1743

1742

1744

/* Process beacon from the current BSS */

1743

/* Process beacon from the current BSS */

1745

baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;

1744

baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;

1746

if (baselen > len)

1745

if (baselen > len)

1747

return;

1746

return;

1748

1747

1749

if (rx_status->freq != local->hw.conf.channel->center_freq)

1748

if (rx_status->freq != local->hw.conf.channel->center_freq)

1750

return;

1749

return;

1751

1750

1752

/*

1751

/*

1753

* We might have received a number of frames, among them a

1752

* We might have received a number of frames, among them a

1754

* disassoc frame and a beacon...

1753

* disassoc frame and a beacon...

1755

*/

1754

*/

1756

if (!ifmgd->associated)

1755

if (!ifmgd->associated)

1757

return;

1756

return;

1758

1757

1759

bssid = ifmgd->associated->cbss.bssid;

1758

bssid = ifmgd->associated->cbss.bssid;

1760

1759

1761

/*

1760

/*

1762

* And in theory even frames from a different AP we were just

1761

* And in theory even frames from a different AP we were just

1763

* associated to a split-second ago!

1762

* associated to a split-second ago!

1764

*/

1763

*/

1765

if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0)

1764

if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0)

1766

return;

1765

return;

1767

1766

1768

if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {

1767

if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {

1769

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1768

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1770

if (net_ratelimit()) {

1769

if (net_ratelimit()) {

1771

printk(KERN_DEBUG "%s: cancelling probereq poll due "

1770

printk(KERN_DEBUG "%s: cancelling probereq poll due "

1772

"to a received beacon\n", sdata->dev->name);

1771

"to a received beacon\n", sdata->dev->name);

1773

}

1772

}

1774

#endif

1773

#endif

1775

ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;

1774

ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;

1776

mutex_lock(&local->iflist_mtx);

1775

mutex_lock(&local->iflist_mtx);

1777

ieee80211_recalc_ps(local, -1);

1776

ieee80211_recalc_ps(local, -1);

1778

mutex_unlock(&local->iflist_mtx);

1777

mutex_unlock(&local->iflist_mtx);

1779

}

1778

}

1780

1779

1781

/*

1780

/*

1782

* Push the beacon loss detection into the future since

1781

* Push the beacon loss detection into the future since

1783

* we are processing a beacon from the AP just now.

1782

* we are processing a beacon from the AP just now.

1784

*/

1783

*/

1785

mod_beacon_timer(sdata);

1784

mod_beacon_timer(sdata);

1786

1785

1787

ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);

1786

ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);

1788

ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,

1787

ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,

1789

len - baselen, &elems,

1788

len - baselen, &elems,

1790

care_about_ies, ncrc);

1789

care_about_ies, ncrc);

1791

1790

1792

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)

1791

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)

1793

directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,

1792

directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,

1794

ifmgd->aid);

1793

ifmgd->aid);

1795

1794

1796

if (ncrc != ifmgd->beacon_crc) {

1795

if (ncrc != ifmgd->beacon_crc) {

1797

ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,

1796

ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,

1798

true);

1797

true);

1799

1798

1800

ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,

1799

ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,

1801

elems.wmm_param_len);

1800

elems.wmm_param_len);

1802

}

1801

}

1803

1802

1804

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {

1803

if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {

1805

if (directed_tim) {

1804

if (directed_tim) {

1806

if (local->hw.conf.dynamic_ps_timeout > 0) {

1805

if (local->hw.conf.dynamic_ps_timeout > 0) {

1807

local->hw.conf.flags &= ~IEEE80211_CONF_PS;

1806

local->hw.conf.flags &= ~IEEE80211_CONF_PS;

1808

ieee80211_hw_config(local,

1807

ieee80211_hw_config(local,

1809

IEEE80211_CONF_CHANGE_PS);

1808

IEEE80211_CONF_CHANGE_PS);

1810

ieee80211_send_nullfunc(local, sdata, 0);

1809

ieee80211_send_nullfunc(local, sdata, 0);

1811

} else {

1810

} else {

1812

local->pspolling = true;

1811

local->pspolling = true;

1813

1812

1814

/*

1813

/*

1815

* Here is assumed that the driver will be

1814

* Here is assumed that the driver will be

1816

* able to send ps-poll frame and receive a

1815

* able to send ps-poll frame and receive a

1817

* response even though power save mode is

1816

* response even though power save mode is

1818

* enabled, but some drivers might require

1817

* enabled, but some drivers might require

1819

* to disable power save here. This needs

1818

* to disable power save here. This needs

1820

* to be investigated.

1819

* to be investigated.

1821

*/

1820

*/

1822

ieee80211_send_pspoll(local, sdata);

1821

ieee80211_send_pspoll(local, sdata);

1823

}

1822

}

1824

}

1823

}

1825

}

1824

}

1826

1825

1827

if (ncrc == ifmgd->beacon_crc)

1826

if (ncrc == ifmgd->beacon_crc)

1828

return;

1827

return;

1829

ifmgd->beacon_crc = ncrc;

1828

ifmgd->beacon_crc = ncrc;

1830

1829

1831

if (elems.erp_info && elems.erp_info_len >= 1) {

1830

if (elems.erp_info && elems.erp_info_len >= 1) {

1832

erp_valid = true;

1831

erp_valid = true;

1833

erp_value = elems.erp_info[0];

1832

erp_value = elems.erp_info[0];

1834

} else {

1833

} else {

1835

erp_valid = false;

1834

erp_valid = false;

1836

}

1835

}

1837

changed |= ieee80211_handle_bss_capability(sdata,

1836

changed |= ieee80211_handle_bss_capability(sdata,

1838

le16_to_cpu(mgmt->u.beacon.capab_info),

1837

le16_to_cpu(mgmt->u.beacon.capab_info),

1839

erp_valid, erp_value);

1838

erp_valid, erp_value);

1840

1839

1841

1840

1842

if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&

1841

if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&

1843

!(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {

1842

!(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {

1844

struct sta_info *sta;

1843

struct sta_info *sta;

1845

struct ieee80211_supported_band *sband;

1844

struct ieee80211_supported_band *sband;

1846

u16 ap_ht_cap_flags;

1845

u16 ap_ht_cap_flags;

1847

1846

1848

rcu_read_lock();

1847

rcu_read_lock();

1849

1848

1850

sta = sta_info_get(local, bssid);

1849

sta = sta_info_get(local, bssid);

1851

if (WARN_ON(!sta)) {

1850

if (WARN_ON(!sta)) {

1852

rcu_read_unlock();

1851

rcu_read_unlock();

1853

return;

1852

return;

1854

}

1853

}

1855

1854

1856

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

1855

sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

1857

1856

1858

ieee80211_ht_cap_ie_to_sta_ht_cap(sband,

1857

ieee80211_ht_cap_ie_to_sta_ht_cap(sband,

1859

elems.ht_cap_elem, &sta->sta.ht_cap);

1858

elems.ht_cap_elem, &sta->sta.ht_cap);

1860

1859

1861

ap_ht_cap_flags = sta->sta.ht_cap.cap;

1860

ap_ht_cap_flags = sta->sta.ht_cap.cap;

1862

1861

1863

rcu_read_unlock();

1862

rcu_read_unlock();

1864

1863

1865

changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,

1864

changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,

1866

bssid, ap_ht_cap_flags);

1865

bssid, ap_ht_cap_flags);

1867

}

1866

}

1868

1867

1869

/* Note: country IE parsing is done for us by cfg80211 */

1868

/* Note: country IE parsing is done for us by cfg80211 */

1870

if (elems.country_elem) {

1869

if (elems.country_elem) {

1871

/* TODO: IBSS also needs this */

1870

/* TODO: IBSS also needs this */

1872

if (elems.pwr_constr_elem)

1871

if (elems.pwr_constr_elem)

1873

ieee80211_handle_pwr_constr(sdata,

1872

ieee80211_handle_pwr_constr(sdata,

1874

le16_to_cpu(mgmt->u.probe_resp.capab_info),

1873

le16_to_cpu(mgmt->u.probe_resp.capab_info),

1875

elems.pwr_constr_elem,

1874

elems.pwr_constr_elem,

1876

elems.pwr_constr_elem_len);

1875

elems.pwr_constr_elem_len);

1877

}

1876

}

1878

1877

1879

ieee80211_bss_info_change_notify(sdata, changed);

1878

ieee80211_bss_info_change_notify(sdata, changed);

1880

}

1879

}

1881

1880

1882

ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,

1881

ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,

1883

struct sk_buff *skb)

1882

struct sk_buff *skb)

1884

{

1883

{

1885

struct ieee80211_local *local = sdata->local;

1884

struct ieee80211_local *local = sdata->local;

1886

struct ieee80211_mgmt *mgmt;

1885

struct ieee80211_mgmt *mgmt;

1887

u16 fc;

1886

u16 fc;

1888

1887

1889

if (skb->len < 24)

1888

if (skb->len < 24)

1890

return RX_DROP_MONITOR;

1889

return RX_DROP_MONITOR;

1891

1890

1892

mgmt = (struct ieee80211_mgmt *) skb->data;

1891

mgmt = (struct ieee80211_mgmt *) skb->data;

1893

fc = le16_to_cpu(mgmt->frame_control);

1892

fc = le16_to_cpu(mgmt->frame_control);

1894

1893

1895

switch (fc & IEEE80211_FCTL_STYPE) {

1894

switch (fc & IEEE80211_FCTL_STYPE) {

1896

case IEEE80211_STYPE_PROBE_REQ:

1895

case IEEE80211_STYPE_PROBE_REQ:

1897

case IEEE80211_STYPE_PROBE_RESP:

1896

case IEEE80211_STYPE_PROBE_RESP:

1898

case IEEE80211_STYPE_BEACON:

1897

case IEEE80211_STYPE_BEACON:

1899

case IEEE80211_STYPE_AUTH:

1898

case IEEE80211_STYPE_AUTH:

1900

case IEEE80211_STYPE_ASSOC_RESP:

1899

case IEEE80211_STYPE_ASSOC_RESP:

1901

case IEEE80211_STYPE_REASSOC_RESP:

1900

case IEEE80211_STYPE_REASSOC_RESP:

1902

case IEEE80211_STYPE_DEAUTH:

1901

case IEEE80211_STYPE_DEAUTH:

1903

case IEEE80211_STYPE_DISASSOC:

1902

case IEEE80211_STYPE_DISASSOC:

1904

case IEEE80211_STYPE_ACTION:

1903

case IEEE80211_STYPE_ACTION:

1905

skb_queue_tail(&sdata->u.mgd.skb_queue, skb);

1904

skb_queue_tail(&sdata->u.mgd.skb_queue, skb);

1906

ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);

1905

ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);

1907

return RX_QUEUED;

1906

return RX_QUEUED;

1908

}

1907

}

1909

1908

1910

return RX_DROP_MONITOR;

1909

return RX_DROP_MONITOR;

1911

}

1910

}

1912

1911

1913

static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,

1912

static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,

1914

struct sk_buff *skb)

1913

struct sk_buff *skb)

1915

{

1914

{

1916

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1915

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

1917

struct ieee80211_rx_status *rx_status;

1916

struct ieee80211_rx_status *rx_status;

1918

struct ieee80211_mgmt *mgmt;

1917

struct ieee80211_mgmt *mgmt;

1919

struct ieee80211_mgd_work *wk;

1918

struct ieee80211_mgd_work *wk;

1920

enum rx_mgmt_action rma = RX_MGMT_NONE;

1919

enum rx_mgmt_action rma = RX_MGMT_NONE;

1921

u16 fc;

1920

u16 fc;

1922

1921

1923

rx_status = (struct ieee80211_rx_status *) skb->cb;

1922

rx_status = (struct ieee80211_rx_status *) skb->cb;

1924

mgmt = (struct ieee80211_mgmt *) skb->data;

1923

mgmt = (struct ieee80211_mgmt *) skb->data;

1925

fc = le16_to_cpu(mgmt->frame_control);

1924

fc = le16_to_cpu(mgmt->frame_control);

1926

1925

1927

mutex_lock(&ifmgd->mtx);

1926

mutex_lock(&ifmgd->mtx);

1928

1927

1929

if (ifmgd->associated &&

1928

if (ifmgd->associated &&

1930

memcmp(ifmgd->associated->cbss.bssid, mgmt->bssid,

1929

memcmp(ifmgd->associated->cbss.bssid, mgmt->bssid,

1931

ETH_ALEN) == 0) {

1930

ETH_ALEN) == 0) {

1932

switch (fc & IEEE80211_FCTL_STYPE) {

1931

switch (fc & IEEE80211_FCTL_STYPE) {

1933

case IEEE80211_STYPE_BEACON:

1932

case IEEE80211_STYPE_BEACON:

1934

ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,

1933

ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,

1935

rx_status);

1934

rx_status);

1936

break;

1935

break;

1937

case IEEE80211_STYPE_PROBE_RESP:

1936

case IEEE80211_STYPE_PROBE_RESP:

1938

ieee80211_rx_mgmt_probe_resp(sdata, NULL, mgmt,

1937

ieee80211_rx_mgmt_probe_resp(sdata, NULL, mgmt,

1939

skb->len, rx_status);

1938

skb->len, rx_status);

1940

break;

1939

break;

1941

case IEEE80211_STYPE_DEAUTH:

1940

case IEEE80211_STYPE_DEAUTH:

1942

rma = ieee80211_rx_mgmt_deauth(sdata, NULL,

1941

rma = ieee80211_rx_mgmt_deauth(sdata, NULL,

1943

mgmt, skb->len);

1942

mgmt, skb->len);

1944

break;

1943

break;

1945

case IEEE80211_STYPE_DISASSOC:

1944

case IEEE80211_STYPE_DISASSOC:

1946

rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);

1945

rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);

1947

break;

1946

break;

1948

case IEEE80211_STYPE_ACTION:

1947

case IEEE80211_STYPE_ACTION:

1949

/* XXX: differentiate, can only happen for CSA now! */

1948

/* XXX: differentiate, can only happen for CSA now! */

1950

ieee80211_sta_process_chanswitch(sdata,

1949

ieee80211_sta_process_chanswitch(sdata,

1951

&mgmt->u.action.u.chan_switch.sw_elem,

1950

&mgmt->u.action.u.chan_switch.sw_elem,

1952

ifmgd->associated);

1951

ifmgd->associated);

1953

break;

1952

break;

1954

}

1953

}

1955

mutex_unlock(&ifmgd->mtx);

1954

mutex_unlock(&ifmgd->mtx);

1956

1955

1957

switch (rma) {

1956

switch (rma) {

1958

case RX_MGMT_NONE:

1957

case RX_MGMT_NONE:

1959

/* no action */

1958

/* no action */

1960

break;

1959

break;

1961

case RX_MGMT_CFG80211_DEAUTH:

1960

case RX_MGMT_CFG80211_DEAUTH:

1962

cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len,

1961

cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len,

1963

NULL);

1962

NULL);

1964

break;

1963

break;

1965

case RX_MGMT_CFG80211_DISASSOC:

1964

case RX_MGMT_CFG80211_DISASSOC:

1966

cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len,

1965

cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len,

1967

NULL);

1966

NULL);

1968

break;

1967

break;

1969

default:

1968

default:

1970

WARN(1, "unexpected: %d", rma);

1969

WARN(1, "unexpected: %d", rma);

1971

}

1970

}

1972

goto out;

1971

goto out;

1973

}

1972

}

1974

1973

1975

list_for_each_entry(wk, &ifmgd->work_list, list) {

1974

list_for_each_entry(wk, &ifmgd->work_list, list) {

1976

if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)

1975

if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)

1977

continue;

1976

continue;

1978

1977

1979

switch (fc & IEEE80211_FCTL_STYPE) {

1978

switch (fc & IEEE80211_FCTL_STYPE) {

1980

case IEEE80211_STYPE_PROBE_RESP:

1979

case IEEE80211_STYPE_PROBE_RESP:

1981

ieee80211_rx_mgmt_probe_resp(sdata, wk, mgmt, skb->len,

1980

ieee80211_rx_mgmt_probe_resp(sdata, wk, mgmt, skb->len,

1982

rx_status);

1981

rx_status);

1983

break;

1982

break;

1984

case IEEE80211_STYPE_AUTH:

1983

case IEEE80211_STYPE_AUTH:

1985

rma = ieee80211_rx_mgmt_auth(sdata, wk, mgmt, skb->len);

1984

rma = ieee80211_rx_mgmt_auth(sdata, wk, mgmt, skb->len);

1986

break;

1985

break;

1987

case IEEE80211_STYPE_ASSOC_RESP:

1986

case IEEE80211_STYPE_ASSOC_RESP:

1988

rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,

1987

rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,

1989

skb->len, false);

1988

skb->len, false);

1990

break;

1989

break;

1991

case IEEE80211_STYPE_REASSOC_RESP:

1990

case IEEE80211_STYPE_REASSOC_RESP:

1992

rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,

1991

rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,

1993

skb->len, true);

1992

skb->len, true);

1994

break;

1993

break;

1995

case IEEE80211_STYPE_DEAUTH:

1994

case IEEE80211_STYPE_DEAUTH:

1996

rma = ieee80211_rx_mgmt_deauth(sdata, wk, mgmt,

1995

rma = ieee80211_rx_mgmt_deauth(sdata, wk, mgmt,

1997

skb->len);

1996

skb->len);

1998

break;

1997

break;

1999

}

1998

}

2000

/*

1999

/*

2001

* We've processed this frame for that work, so it can't

2000

* We've processed this frame for that work, so it can't

2002

* belong to another work struct.

2001

* belong to another work struct.

2003

* NB: this is also required for correctness because the

2002

* NB: this is also required for correctness because the

2004

* called functions can free 'wk', and for 'rma'!

2003

* called functions can free 'wk', and for 'rma'!

2005

*/

2004

*/

2006

break;

2005

break;

2007

}

2006

}

2008

2007

2009

mutex_unlock(&ifmgd->mtx);

2008

mutex_unlock(&ifmgd->mtx);

2010

2009

2011

switch (rma) {

2010

switch (rma) {

2012

case RX_MGMT_NONE:

2011

case RX_MGMT_NONE:

2013

/* no action */

2012

/* no action */

2014

break;

2013

break;

2015

case RX_MGMT_CFG80211_AUTH:

2014

case RX_MGMT_CFG80211_AUTH:

2016

cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, skb->len);

2015

cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, skb->len);

2017

break;

2016

break;

2018

case RX_MGMT_CFG80211_ASSOC:

2017

case RX_MGMT_CFG80211_ASSOC:

2019

cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, skb->len);

2018

cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, skb->len);

2020

break;

2019

break;

2021

case RX_MGMT_CFG80211_DEAUTH:

2020

case RX_MGMT_CFG80211_DEAUTH:

2022

cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, NULL);

2021

cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, NULL);

2023

break;

2022

break;

2024

default:

2023

default:

2025

WARN(1, "unexpected: %d", rma);

2024

WARN(1, "unexpected: %d", rma);

2026

}

2025

}

2027

2026

2028

out:

2027

out:

2029

kfree_skb(skb);

2028

kfree_skb(skb);

2030

}

2029

}

2031

2030

2032

static void ieee80211_sta_timer(unsigned long data)

2031

static void ieee80211_sta_timer(unsigned long data)

2033

{

2032

{

2034

struct ieee80211_sub_if_data *sdata =

2033

struct ieee80211_sub_if_data *sdata =

2035

(struct ieee80211_sub_if_data *) data;

2034

(struct ieee80211_sub_if_data *) data;

2036

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2035

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2037

struct ieee80211_local *local = sdata->local;

2036

struct ieee80211_local *local = sdata->local;

2038

2037

2039

if (local->quiescing) {

2038

if (local->quiescing) {

2040

set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);

2039

set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);

2041

return;

2040

return;

2042

}

2041

}

2043

2042

2044

ieee80211_queue_work(&local->hw, &ifmgd->work);

2043

ieee80211_queue_work(&local->hw, &ifmgd->work);

2045

}

2044

}

2046

2045

2047

static void ieee80211_sta_work(struct work_struct *work)

2046

static void ieee80211_sta_work(struct work_struct *work)

2048

{

2047

{

2049

struct ieee80211_sub_if_data *sdata =

2048

struct ieee80211_sub_if_data *sdata =

2050

container_of(work, struct ieee80211_sub_if_data, u.mgd.work);

2049

container_of(work, struct ieee80211_sub_if_data, u.mgd.work);

2051

struct ieee80211_local *local = sdata->local;

2050

struct ieee80211_local *local = sdata->local;

2052

struct ieee80211_if_managed *ifmgd;

2051

struct ieee80211_if_managed *ifmgd;

2053

struct sk_buff *skb;

2052

struct sk_buff *skb;

2054

struct ieee80211_mgd_work *wk, *tmp;

2053

struct ieee80211_mgd_work *wk, *tmp;

2055

LIST_HEAD(free_work);

2054

LIST_HEAD(free_work);

2056

enum rx_mgmt_action rma;

2055

enum rx_mgmt_action rma;

2057

bool anybusy = false;

2056

bool anybusy = false;

2058

2057

2059

if (!netif_running(sdata->dev))

2058

if (!netif_running(sdata->dev))

2060

return;

2059

return;

2061

2060

2062

if (local->scanning)

2061

if (local->scanning)

2063

return;

2062

return;

2064

2063

2065

if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))

2064

if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))

2066

return;

2065

return;

2067

2066

2068

/*

2067

/*

2069

* ieee80211_queue_work() should have picked up most cases,

2068

* ieee80211_queue_work() should have picked up most cases,

2070

* here we'll pick the the rest.

2069

* here we'll pick the the rest.

2071

*/

2070

*/

2072

if (WARN(local->suspended, "STA MLME work scheduled while "

2071

if (WARN(local->suspended, "STA MLME work scheduled while "

2073

"going to suspend\n"))

2072

"going to suspend\n"))

2074

return;

2073

return;

2075

2074

2076

ifmgd = &sdata->u.mgd;

2075

ifmgd = &sdata->u.mgd;

2077

2076

2078

/* first process frames to avoid timing out while a frame is pending */

2077

/* first process frames to avoid timing out while a frame is pending */

2079

while ((skb = skb_dequeue(&ifmgd->skb_queue)))

2078

while ((skb = skb_dequeue(&ifmgd->skb_queue)))

2080

ieee80211_sta_rx_queued_mgmt(sdata, skb);

2079

ieee80211_sta_rx_queued_mgmt(sdata, skb);

2081

2080

2082

/* then process the rest of the work */

2081

/* then process the rest of the work */

2083

mutex_lock(&ifmgd->mtx);

2082

mutex_lock(&ifmgd->mtx);

2084

2083

2085

if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |

2084

if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |

2086

IEEE80211_STA_CONNECTION_POLL) &&

2085

IEEE80211_STA_CONNECTION_POLL) &&

2087

ifmgd->associated) {

2086

ifmgd->associated) {

2088

u8 bssid[ETH_ALEN];

2087

u8 bssid[ETH_ALEN];

2089

2088

2090

memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);

2089

memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);

2091

if (time_is_after_jiffies(ifmgd->probe_timeout))

2090

if (time_is_after_jiffies(ifmgd->probe_timeout))

2092

run_again(ifmgd, ifmgd->probe_timeout);

2091

run_again(ifmgd, ifmgd->probe_timeout);

2093

2092

2094

else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) {

2093

else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) {

2095

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

2094

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

2096

printk(KERN_DEBUG "No probe response from AP %pM"

2095

printk(KERN_DEBUG "No probe response from AP %pM"

2097

" after %dms, try %d\n", bssid,

2096

" after %dms, try %d\n", bssid,

2098

(1000 * IEEE80211_PROBE_WAIT)/HZ,

2097

(1000 * IEEE80211_PROBE_WAIT)/HZ,

2099

ifmgd->probe_send_count);

2098

ifmgd->probe_send_count);

2100

#endif

2099

#endif

2101

ieee80211_mgd_probe_ap_send(sdata);

2100

ieee80211_mgd_probe_ap_send(sdata);

2102

} else {

2101

} else {

2103

/*

2102

/*

2104

* We actually lost the connection ... or did we?

2103

* We actually lost the connection ... or did we?

2105

* Let's make sure!

2104

* Let's make sure!

2106

*/

2105

*/

2107

ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |

2106

ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |

2108

IEEE80211_STA_BEACON_POLL);

2107

IEEE80211_STA_BEACON_POLL);

2109

printk(KERN_DEBUG "No probe response from AP %pM"

2108

printk(KERN_DEBUG "No probe response from AP %pM"

2110

" after %dms, disconnecting.\n",

2109

" after %dms, disconnecting.\n",

2111

bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);

2110

bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);

2112

ieee80211_set_disassoc(sdata, true);

2111

ieee80211_set_disassoc(sdata, true);

2113

mutex_unlock(&ifmgd->mtx);

2112

mutex_unlock(&ifmgd->mtx);

2114

/*

2113

/*

2115

* must be outside lock due to cfg80211,

2114

* must be outside lock due to cfg80211,

2116

* but that's not a problem.

2115

* but that's not a problem.

2117

*/

2116

*/

2118

ieee80211_send_deauth_disassoc(sdata, bssid,

2117

ieee80211_send_deauth_disassoc(sdata, bssid,

2119

IEEE80211_STYPE_DEAUTH,

2118

IEEE80211_STYPE_DEAUTH,

2120

WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,

2119

WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,

2121

NULL);

2120

NULL);

2122

mutex_lock(&ifmgd->mtx);

2121

mutex_lock(&ifmgd->mtx);

2123

}

2122

}

2124

}

2123

}

2125

2124

2126

2125

2127

ieee80211_recalc_idle(local);

2126

ieee80211_recalc_idle(local);

2128

2127

2129

list_for_each_entry_safe(wk, tmp, &ifmgd->work_list, list) {

2128

list_for_each_entry_safe(wk, tmp, &ifmgd->work_list, list) {

2130

if (time_is_after_jiffies(wk->timeout)) {

2129

if (time_is_after_jiffies(wk->timeout)) {

2131

/*

2130

/*

2132

* This work item isn't supposed to be worked on

2131

* This work item isn't supposed to be worked on

2133

* right now, but take care to adjust the timer

2132

* right now, but take care to adjust the timer

2134

* properly.

2133

* properly.

2135

*/

2134

*/

2136

run_again(ifmgd, wk->timeout);

2135

run_again(ifmgd, wk->timeout);

2137

continue;

2136

continue;

2138

}

2137

}

2139

2138

2140

switch (wk->state) {

2139

switch (wk->state) {

2141

default:

2140

default:

2142

WARN_ON(1);

2141

WARN_ON(1);

2143

/* fall through */

2142

/* fall through */

2144

case IEEE80211_MGD_STATE_IDLE:

2143

case IEEE80211_MGD_STATE_IDLE:

2145

/* nothing */

2144

/* nothing */

2146

rma = RX_MGMT_NONE;

2145

rma = RX_MGMT_NONE;

2147

break;

2146

break;

2148

case IEEE80211_MGD_STATE_PROBE:

2147

case IEEE80211_MGD_STATE_PROBE:

2149

rma = ieee80211_direct_probe(sdata, wk);

2148

rma = ieee80211_direct_probe(sdata, wk);

2150

break;

2149

break;

2151

case IEEE80211_MGD_STATE_AUTH:

2150

case IEEE80211_MGD_STATE_AUTH:

2152

rma = ieee80211_authenticate(sdata, wk);

2151

rma = ieee80211_authenticate(sdata, wk);

2153

break;

2152

break;

2154

case IEEE80211_MGD_STATE_ASSOC:

2153

case IEEE80211_MGD_STATE_ASSOC:

2155

rma = ieee80211_associate(sdata, wk);

2154

rma = ieee80211_associate(sdata, wk);

2156

break;

2155

break;

2157

}

2156

}

2158

2157

2159

switch (rma) {

2158

switch (rma) {

2160

case RX_MGMT_NONE:

2159

case RX_MGMT_NONE:

2161

/* no action required */

2160

/* no action required */

2162

break;

2161

break;

2163

case RX_MGMT_CFG80211_AUTH_TO:

2162

case RX_MGMT_CFG80211_AUTH_TO:

2164

case RX_MGMT_CFG80211_ASSOC_TO:

2163

case RX_MGMT_CFG80211_ASSOC_TO:

2165

list_del(&wk->list);

2164

list_del(&wk->list);

2166

list_add(&wk->list, &free_work);

2165

list_add(&wk->list, &free_work);

2167

wk->tries = rma; /* small abuse but only local */

2166

wk->tries = rma; /* small abuse but only local */

2168

break;

2167

break;

2169

default:

2168

default:

2170

WARN(1, "unexpected: %d", rma);

2169

WARN(1, "unexpected: %d", rma);

2171

}

2170

}

2172

}

2171

}

2173

2172

2174

list_for_each_entry(wk, &ifmgd->work_list, list) {

2173

list_for_each_entry(wk, &ifmgd->work_list, list) {

2175

if (wk->state != IEEE80211_MGD_STATE_IDLE) {

2174

if (wk->state != IEEE80211_MGD_STATE_IDLE) {

2176

anybusy = true;

2175

anybusy = true;

2177

break;

2176

break;

2178

}

2177

}

2179

}

2178

}

2180

if (!anybusy &&

2179

if (!anybusy &&

2181

test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request))

2180

test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request))

2182

ieee80211_queue_delayed_work(&local->hw,

2181

ieee80211_queue_delayed_work(&local->hw,

2183

&local->scan_work,

2182

&local->scan_work,

2184

round_jiffies_relative(0));

2183

round_jiffies_relative(0));

2185

2184

2186

mutex_unlock(&ifmgd->mtx);

2185

mutex_unlock(&ifmgd->mtx);

2187

2186

2188

list_for_each_entry_safe(wk, tmp, &free_work, list) {

2187

list_for_each_entry_safe(wk, tmp, &free_work, list) {

2189

switch (wk->tries) {

2188

switch (wk->tries) {

2190

case RX_MGMT_CFG80211_AUTH_TO:

2189

case RX_MGMT_CFG80211_AUTH_TO:

2191

cfg80211_send_auth_timeout(sdata->dev,

2190

cfg80211_send_auth_timeout(sdata->dev,

2192

wk->bss->cbss.bssid);

2191

wk->bss->cbss.bssid);

2193

break;

2192

break;

2194

case RX_MGMT_CFG80211_ASSOC_TO:

2193

case RX_MGMT_CFG80211_ASSOC_TO:

2195

cfg80211_send_assoc_timeout(sdata->dev,

2194

cfg80211_send_assoc_timeout(sdata->dev,

2196

wk->bss->cbss.bssid);

2195

wk->bss->cbss.bssid);

2197

break;

2196

break;

2198

default:

2197

default:

2199

WARN(1, "unexpected: %d", wk->tries);

2198

WARN(1, "unexpected: %d", wk->tries);

2200

}

2199

}

2201

2200

2202

list_del(&wk->list);

2201

list_del(&wk->list);

2203

kfree(wk);

2202

kfree(wk);

2204

}

2203

}

2205

2204

2206

ieee80211_recalc_idle(local);

2205

ieee80211_recalc_idle(local);

2207

}

2206

}

2208

2207

2209

static void ieee80211_sta_bcn_mon_timer(unsigned long data)

2208

static void ieee80211_sta_bcn_mon_timer(unsigned long data)

2210

{

2209

{

2211

struct ieee80211_sub_if_data *sdata =

2210

struct ieee80211_sub_if_data *sdata =

2212

(struct ieee80211_sub_if_data *) data;

2211

(struct ieee80211_sub_if_data *) data;

2213

struct ieee80211_local *local = sdata->local;

2212

struct ieee80211_local *local = sdata->local;

2214

2213

2215

if (local->quiescing)

2214

if (local->quiescing)

2216

return;

2215

return;

2217

2216

2218

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);

2217

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);

2219

}

2218

}

2220

2219

2221

static void ieee80211_sta_conn_mon_timer(unsigned long data)

2220

static void ieee80211_sta_conn_mon_timer(unsigned long data)

2222

{

2221

{

2223

struct ieee80211_sub_if_data *sdata =

2222

struct ieee80211_sub_if_data *sdata =

2224

(struct ieee80211_sub_if_data *) data;

2223

(struct ieee80211_sub_if_data *) data;

2225

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2224

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2226

struct ieee80211_local *local = sdata->local;

2225

struct ieee80211_local *local = sdata->local;

2227

2226

2228

if (local->quiescing)

2227

if (local->quiescing)

2229

return;

2228

return;

2230

2229

2231

ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);

2230

ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);

2232

}

2231

}

2233

2232

2234

static void ieee80211_sta_monitor_work(struct work_struct *work)

2233

static void ieee80211_sta_monitor_work(struct work_struct *work)

2235

{

2234

{

2236

struct ieee80211_sub_if_data *sdata =

2235

struct ieee80211_sub_if_data *sdata =

2237

container_of(work, struct ieee80211_sub_if_data,

2236

container_of(work, struct ieee80211_sub_if_data,

2238

u.mgd.monitor_work);

2237

u.mgd.monitor_work);

2239

2238

2240

ieee80211_mgd_probe_ap(sdata, false);

2239

ieee80211_mgd_probe_ap(sdata, false);

2241

}

2240

}

2242

2241

2243

static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)

2242

static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)

2244

{

2243

{

2245

if (sdata->vif.type == NL80211_IFTYPE_STATION) {

2244

if (sdata->vif.type == NL80211_IFTYPE_STATION) {

2246

sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |

2245

sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |

2247

IEEE80211_STA_CONNECTION_POLL);

2246

IEEE80211_STA_CONNECTION_POLL);

2248

2247

2249

/* let's probe the connection once */

2248

/* let's probe the connection once */

2250

ieee80211_queue_work(&sdata->local->hw,

2249

ieee80211_queue_work(&sdata->local->hw,

2251

&sdata->u.mgd.monitor_work);

2250

&sdata->u.mgd.monitor_work);

2252

/* and do all the other regular work too */

2251

/* and do all the other regular work too */

2253

ieee80211_queue_work(&sdata->local->hw,

2252

ieee80211_queue_work(&sdata->local->hw,

2254

&sdata->u.mgd.work);

2253

&sdata->u.mgd.work);

2255

}

2254

}

2256

}

2255

}

2257

2256

2258

#ifdef CONFIG_PM

2257

#ifdef CONFIG_PM

2259

void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)

2258

void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)

2260

{

2259

{

2261

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2260

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2262

2261

2263

/*

2262

/*

2264

* we need to use atomic bitops for the running bits

2263

* we need to use atomic bitops for the running bits

2265

* only because both timers might fire at the same

2264

* only because both timers might fire at the same

2266

* time -- the code here is properly synchronised.

2265

* time -- the code here is properly synchronised.

2267

*/

2266

*/

2268

2267

2269

cancel_work_sync(&ifmgd->work);

2268

cancel_work_sync(&ifmgd->work);

2270

cancel_work_sync(&ifmgd->beacon_loss_work);

2269

cancel_work_sync(&ifmgd->beacon_loss_work);

2271

if (del_timer_sync(&ifmgd->timer))

2270

if (del_timer_sync(&ifmgd->timer))

2272

set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);

2271

set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);

2273

2272

2274

cancel_work_sync(&ifmgd->chswitch_work);

2273

cancel_work_sync(&ifmgd->chswitch_work);

2275

if (del_timer_sync(&ifmgd->chswitch_timer))

2274

if (del_timer_sync(&ifmgd->chswitch_timer))

2276

set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);

2275

set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);

2277

2276

2278

cancel_work_sync(&ifmgd->monitor_work);

2277

cancel_work_sync(&ifmgd->monitor_work);

2279

/* these will just be re-established on connection */

2278

/* these will just be re-established on connection */

2280

del_timer_sync(&ifmgd->conn_mon_timer);

2279

del_timer_sync(&ifmgd->conn_mon_timer);

2281

del_timer_sync(&ifmgd->bcn_mon_timer);

2280

del_timer_sync(&ifmgd->bcn_mon_timer);

2282

}

2281

}

2283

2282

2284

void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)

2283

void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)

2285

{

2284

{

2286

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2285

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2287

2286

2288

if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))

2287

if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))

2289

add_timer(&ifmgd->timer);

2288

add_timer(&ifmgd->timer);

2290

if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))

2289

if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))

2291

add_timer(&ifmgd->chswitch_timer);

2290

add_timer(&ifmgd->chswitch_timer);

2292

}

2291

}

2293

#endif

2292

#endif

2294

2293

2295

/* interface setup */

2294

/* interface setup */

2296

void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)

2295

void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)

2297

{

2296

{

2298

struct ieee80211_if_managed *ifmgd;

2297

struct ieee80211_if_managed *ifmgd;

2299

2298

2300

ifmgd = &sdata->u.mgd;

2299

ifmgd = &sdata->u.mgd;

2301

INIT_WORK(&ifmgd->work, ieee80211_sta_work);

2300

INIT_WORK(&ifmgd->work, ieee80211_sta_work);

2302

INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);

2301

INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);

2303

INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);

2302

INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);

2304

INIT_WORK(&ifmgd->beacon_loss_work, ieee80211_beacon_loss_work);

2303

INIT_WORK(&ifmgd->beacon_loss_work, ieee80211_beacon_loss_work);

2305

setup_timer(&ifmgd->timer, ieee80211_sta_timer,

2304

setup_timer(&ifmgd->timer, ieee80211_sta_timer,

2306

(unsigned long) sdata);

2305

(unsigned long) sdata);

2307

setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,

2306

setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,

2308

(unsigned long) sdata);

2307

(unsigned long) sdata);

2309

setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,

2308

setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,

2310

(unsigned long) sdata);

2309

(unsigned long) sdata);

2311

setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,

2310

setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,

2312

(unsigned long) sdata);

2311

(unsigned long) sdata);

2313

skb_queue_head_init(&ifmgd->skb_queue);

2312

skb_queue_head_init(&ifmgd->skb_queue);

2314

2313

2315

INIT_LIST_HEAD(&ifmgd->work_list);

2314

INIT_LIST_HEAD(&ifmgd->work_list);

2316

2315

2317

ifmgd->capab = WLAN_CAPABILITY_ESS;

2316

ifmgd->capab = WLAN_CAPABILITY_ESS;

2318

ifmgd->flags = 0;

2317

ifmgd->flags = 0;

2319

if (sdata->local->hw.queues >= 4)

2318

if (sdata->local->hw.queues >= 4)

2320

ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;

2319

ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;

2321

2320

2322

mutex_init(&ifmgd->mtx);

2321

mutex_init(&ifmgd->mtx);

2323

}

2322

}

2324

2323

2325

/* scan finished notification */

2324

/* scan finished notification */

2326

void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)

2325

void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)

2327

{

2326

{

2328

struct ieee80211_sub_if_data *sdata = local->scan_sdata;

2327

struct ieee80211_sub_if_data *sdata = local->scan_sdata;

2329

2328

2330

/* Restart STA timers */

2329

/* Restart STA timers */

2331

rcu_read_lock();

2330

rcu_read_lock();

2332

list_for_each_entry_rcu(sdata, &local->interfaces, list)

2331

list_for_each_entry_rcu(sdata, &local->interfaces, list)

2333

ieee80211_restart_sta_timer(sdata);

2332

ieee80211_restart_sta_timer(sdata);

2334

rcu_read_unlock();

2333

rcu_read_unlock();

2335

}

2334

}

2336

2335

2337

int ieee80211_max_network_latency(struct notifier_block *nb,

2336

int ieee80211_max_network_latency(struct notifier_block *nb,

2338

unsigned long data, void *dummy)

2337

unsigned long data, void *dummy)

2339

{

2338

{

2340

s32 latency_usec = (s32) data;

2339

s32 latency_usec = (s32) data;

2341

struct ieee80211_local *local =

2340

struct ieee80211_local *local =

2342

container_of(nb, struct ieee80211_local,

2341

container_of(nb, struct ieee80211_local,

2343

network_latency_notifier);

2342

network_latency_notifier);

2344

2343

2345

mutex_lock(&local->iflist_mtx);

2344

mutex_lock(&local->iflist_mtx);

2346

ieee80211_recalc_ps(local, latency_usec);

2345

ieee80211_recalc_ps(local, latency_usec);

2347

mutex_unlock(&local->iflist_mtx);

2346

mutex_unlock(&local->iflist_mtx);

2348

2347

2349

return 0;

2348

return 0;

2350

}

2349

}

2351

2350

2352

/* config hooks */

2351

/* config hooks */

2353

int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,

2352

int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,

2354

struct cfg80211_auth_request *req)

2353

struct cfg80211_auth_request *req)

2355

{

2354

{

2356

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2355

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2357

const u8 *ssid;

2356

const u8 *ssid;

2358

struct ieee80211_mgd_work *wk;

2357

struct ieee80211_mgd_work *wk;

2359

u16 auth_alg;

2358

u16 auth_alg;

2360

2359

2361

switch (req->auth_type) {

2360

switch (req->auth_type) {

2362

case NL80211_AUTHTYPE_OPEN_SYSTEM:

2361

case NL80211_AUTHTYPE_OPEN_SYSTEM:

2363

auth_alg = WLAN_AUTH_OPEN;

2362

auth_alg = WLAN_AUTH_OPEN;

2364

break;

2363

break;

2365

case NL80211_AUTHTYPE_SHARED_KEY:

2364

case NL80211_AUTHTYPE_SHARED_KEY:

2366

auth_alg = WLAN_AUTH_SHARED_KEY;

2365

auth_alg = WLAN_AUTH_SHARED_KEY;

2367

break;

2366

break;

2368

case NL80211_AUTHTYPE_FT:

2367

case NL80211_AUTHTYPE_FT:

2369

auth_alg = WLAN_AUTH_FT;

2368

auth_alg = WLAN_AUTH_FT;

2370

break;

2369

break;

2371

case NL80211_AUTHTYPE_NETWORK_EAP:

2370

case NL80211_AUTHTYPE_NETWORK_EAP:

2372

auth_alg = WLAN_AUTH_LEAP;

2371

auth_alg = WLAN_AUTH_LEAP;

2373

break;

2372

break;

2374

default:

2373

default:

2375

return -EOPNOTSUPP;

2374

return -EOPNOTSUPP;

2376

}

2375

}

2377

2376

2378

wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);

2377

wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);

2379

if (!wk)

2378

if (!wk)

2380

return -ENOMEM;

2379

return -ENOMEM;

2381

2380

2382

wk->bss = (void *)req->bss;

2381

wk->bss = (void *)req->bss;

2383

2382

2384

if (req->ie && req->ie_len) {

2383

if (req->ie && req->ie_len) {

2385

memcpy(wk->ie, req->ie, req->ie_len);

2384

memcpy(wk->ie, req->ie, req->ie_len);

2386

wk->ie_len = req->ie_len;

2385

wk->ie_len = req->ie_len;

2387

}

2386

}

2388

2387

2389

if (req->key && req->key_len) {

2388

if (req->key && req->key_len) {

2390

wk->key_len = req->key_len;

2389

wk->key_len = req->key_len;

2391

wk->key_idx = req->key_idx;

2390

wk->key_idx = req->key_idx;

2392

memcpy(wk->key, req->key, req->key_len);

2391

memcpy(wk->key, req->key, req->key_len);

2393

}

2392

}

2394

2393

2395

ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);

2394

ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);

2396

memcpy(wk->ssid, ssid + 2, ssid[1]);

2395

memcpy(wk->ssid, ssid + 2, ssid[1]);

2397

wk->ssid_len = ssid[1];

2396

wk->ssid_len = ssid[1];

2398

2397

2399

wk->state = IEEE80211_MGD_STATE_PROBE;

2398

wk->state = IEEE80211_MGD_STATE_PROBE;

2400

wk->auth_alg = auth_alg;

2399

wk->auth_alg = auth_alg;

2401

wk->timeout = jiffies; /* run right away */

2400

wk->timeout = jiffies; /* run right away */

2402

2401

2403

/*

2402

/*

2404

* XXX: if still associated need to tell AP that we're going

2403

* XXX: if still associated need to tell AP that we're going

2405

* to sleep and then change channel etc.

2404

* to sleep and then change channel etc.

2406

*/

2405

*/

2407

sdata->local->oper_channel = req->bss->channel;

2406

sdata->local->oper_channel = req->bss->channel;

2408

ieee80211_hw_config(sdata->local, 0);

2407

ieee80211_hw_config(sdata->local, 0);

2409

2408

2410

mutex_lock(&ifmgd->mtx);

2409

mutex_lock(&ifmgd->mtx);

2411

list_add(&wk->list, &sdata->u.mgd.work_list);

2410

list_add(&wk->list, &sdata->u.mgd.work_list);

2412

mutex_unlock(&ifmgd->mtx);

2411

mutex_unlock(&ifmgd->mtx);

2413

2412

2414

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);

2413

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);

2415

return 0;

2414

return 0;

2416

}

2415

}

2417

2416

2418

int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,

2417

int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,

2419

struct cfg80211_assoc_request *req)

2418

struct cfg80211_assoc_request *req)

2420

{

2419

{

2421

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2420

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2422

struct ieee80211_mgd_work *wk, *found = NULL;

2421

struct ieee80211_mgd_work *wk, *found = NULL;

2423

int i, err;

2422

int i, err;

2424

2423

2425

mutex_lock(&ifmgd->mtx);

2424

mutex_lock(&ifmgd->mtx);

2426

2425

2427

list_for_each_entry(wk, &ifmgd->work_list, list) {

2426

list_for_each_entry(wk, &ifmgd->work_list, list) {

2428

if (&wk->bss->cbss == req->bss &&

2427

if (&wk->bss->cbss == req->bss &&

2429

wk->state == IEEE80211_MGD_STATE_IDLE) {

2428

wk->state == IEEE80211_MGD_STATE_IDLE) {

2430

found = wk;

2429

found = wk;

2431

break;

2430

break;

2432

}

2431

}

2433

}

2432

}

2434

2433

2435

if (!found) {

2434

if (!found) {

2436

err = -ENOLINK;

2435

err = -ENOLINK;

2437

goto out;

2436

goto out;

2438

}

2437

}

2439

2438

2440

list_del(&found->list);

2439

list_del(&found->list);

2441

2440

2442

wk = krealloc(found, sizeof(*wk) + req->ie_len, GFP_KERNEL);

2441

wk = krealloc(found, sizeof(*wk) + req->ie_len, GFP_KERNEL);

2443

if (!wk) {

2442

if (!wk) {

2444

list_add(&found->list, &ifmgd->work_list);

2443

list_add(&found->list, &ifmgd->work_list);

2445

err = -ENOMEM;

2444

err = -ENOMEM;

2446

goto out;

2445

goto out;

2447

}

2446

}

2448

2447

2449

list_add(&wk->list, &ifmgd->work_list);

2448

list_add(&wk->list, &ifmgd->work_list);

2450

2449

2451

ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;

2450

ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;

2452

2451

2453

for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)

2452

for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)

2454

if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||

2453

if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||

2455

req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||

2454

req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||

2456

req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)

2455

req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)

2457

ifmgd->flags |= IEEE80211_STA_DISABLE_11N;

2456

ifmgd->flags |= IEEE80211_STA_DISABLE_11N;

2458

2457

2459

sdata->local->oper_channel = req->bss->channel;

2458

sdata->local->oper_channel = req->bss->channel;

2460

ieee80211_hw_config(sdata->local, 0);

2459

ieee80211_hw_config(sdata->local, 0);

2461

2460

2462

if (req->ie && req->ie_len) {

2461

if (req->ie && req->ie_len) {

2463

memcpy(wk->ie, req->ie, req->ie_len);

2462

memcpy(wk->ie, req->ie, req->ie_len);

2464

wk->ie_len = req->ie_len;

2463

wk->ie_len = req->ie_len;

2465

} else

2464

} else

2466

wk->ie_len = 0;

2465

wk->ie_len = 0;

2467

2466

2468

if (req->prev_bssid)

2467

if (req->prev_bssid)

2469

memcpy(wk->prev_bssid, req->prev_bssid, ETH_ALEN);

2468

memcpy(wk->prev_bssid, req->prev_bssid, ETH_ALEN);

2470

2469

2471

wk->state = IEEE80211_MGD_STATE_ASSOC;

2470

wk->state = IEEE80211_MGD_STATE_ASSOC;

2472

wk->tries = 0;

2471

wk->tries = 0;

2473

wk->timeout = jiffies; /* run right away */

2472

wk->timeout = jiffies; /* run right away */

2474

2473

2475

if (req->use_mfp) {

2474

if (req->use_mfp) {

2476

ifmgd->mfp = IEEE80211_MFP_REQUIRED;

2475

ifmgd->mfp = IEEE80211_MFP_REQUIRED;

2477

ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;

2476

ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;

2478

} else {

2477

} else {

2479

ifmgd->mfp = IEEE80211_MFP_DISABLED;

2478

ifmgd->mfp = IEEE80211_MFP_DISABLED;

2480

ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;

2479

ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;

2481

}

2480

}

2482

2481

2483

if (req->crypto.control_port)

2482

if (req->crypto.control_port)

2484

ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;

2483

ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;

2485

else

2484

else

2486

ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;

2485

ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;

2487

2486

2488

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);

2487

ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);

2489

2488

2490

err = 0;

2489

err = 0;

2491

2490

2492

out:

2491

out:

2493

mutex_unlock(&ifmgd->mtx);

2492

mutex_unlock(&ifmgd->mtx);

2494

return err;

2493

return err;

2495

}

2494

}

2496

2495

2497

int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,

2496

int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,

2498

struct cfg80211_deauth_request *req,

2497

struct cfg80211_deauth_request *req,

2499

void *cookie)

2498

void *cookie)

2500

{

2499

{

2501

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2500

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2502

struct ieee80211_mgd_work *wk;

2501

struct ieee80211_mgd_work *wk;

2503

const u8 *bssid = NULL;

2502

const u8 *bssid = NULL;

2504

2503

2505

mutex_lock(&ifmgd->mtx);

2504

mutex_lock(&ifmgd->mtx);

2506

2505

2507

if (ifmgd->associated && &ifmgd->associated->cbss == req->bss) {

2506

if (ifmgd->associated && &ifmgd->associated->cbss == req->bss) {

2508

bssid = req->bss->bssid;

2507

bssid = req->bss->bssid;

2509

ieee80211_set_disassoc(sdata, true);

2508

ieee80211_set_disassoc(sdata, true);

2510

} else list_for_each_entry(wk, &ifmgd->work_list, list) {

2509

} else list_for_each_entry(wk, &ifmgd->work_list, list) {

2511

if (&wk->bss->cbss == req->bss) {

2510

if (&wk->bss->cbss == req->bss) {

2512

bssid = req->bss->bssid;

2511

bssid = req->bss->bssid;

2513

list_del(&wk->list);

2512

list_del(&wk->list);

2514

kfree(wk);

2513

kfree(wk);

2515

break;

2514

break;

2516

}

2515

}

2517

}

2516

}

2518

2517

2519

/*

2518

/*

2520

* cfg80211 should catch this ... but it's racy since

2519

* cfg80211 should catch this ... but it's racy since

2521

* we can receive a deauth frame, process it, hand it

2520

* we can receive a deauth frame, process it, hand it

2522

* to cfg80211 while that's in a locked section already

2521

* to cfg80211 while that's in a locked section already

2523

* trying to tell us that the user wants to disconnect.

2522

* trying to tell us that the user wants to disconnect.

2524

*/

2523

*/

2525

if (!bssid) {

2524

if (!bssid) {

2526

mutex_unlock(&ifmgd->mtx);

2525

mutex_unlock(&ifmgd->mtx);

2527

return -ENOLINK;

2526

return -ENOLINK;

2528

}

2527

}

2529

2528

2530

mutex_unlock(&ifmgd->mtx);

2529

mutex_unlock(&ifmgd->mtx);

2531

2530

2532

printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n",

2531

printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n",

2533

sdata->dev->name, bssid, req->reason_code);

2532

sdata->dev->name, bssid, req->reason_code);

2534

2533

2535

ieee80211_send_deauth_disassoc(sdata, bssid,

2534

ieee80211_send_deauth_disassoc(sdata, bssid,

2536

IEEE80211_STYPE_DEAUTH, req->reason_code,

2535

IEEE80211_STYPE_DEAUTH, req->reason_code,

2537

cookie);

2536

cookie);

2538

2537

2539

return 0;

2538

return 0;

2540

}

2539

}

2541

2540

2542

int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,

2541

int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,

2543

struct cfg80211_disassoc_request *req,

2542

struct cfg80211_disassoc_request *req,

2544

void *cookie)

2543

void *cookie)

2545

{

2544

{

2546

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2545

struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2547

2546

2548

mutex_lock(&ifmgd->mtx);

2547

mutex_lock(&ifmgd->mtx);

2549

2548

2550

/*

2549

/*

2551

* cfg80211 should catch this ... but it's racy since

2550

* cfg80211 should catch this ... but it's racy since

2552

* we can receive a disassoc frame, process it, hand it

2551

* we can receive a disassoc frame, process it, hand it

2553

* to cfg80211 while that's in a locked section already

2552

* to cfg80211 while that's in a locked section already

2554

* trying to tell us that the user wants to disconnect.

2553

* trying to tell us that the user wants to disconnect.

2555

*/

2554

*/

2556

if (&ifmgd->associated->cbss != req->bss) {

2555

if (&ifmgd->associated->cbss != req->bss) {

2557

mutex_unlock(&ifmgd->mtx);

2556

mutex_unlock(&ifmgd->mtx);

2558

return -ENOLINK;

2557

return -ENOLINK;

2559

}

2558

}

2560

2559

2561

printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",

2560

printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",

2562

sdata->dev->name, req->bss->bssid, req->reason_code);

2561

sdata->dev->name, req->bss->bssid, req->reason_code);

2563

2562

2564

ieee80211_set_disassoc(sdata, false);

2563

ieee80211_set_disassoc(sdata, false);

2565

2564

2566

mutex_unlock(&ifmgd->mtx);

2565

mutex_unlock(&ifmgd->mtx);

2567

2566

2568

ieee80211_send_deauth_disassoc(sdata, req->bss->bssid,

2567

ieee80211_send_deauth_disassoc(sdata, req->bss->bssid,

2569

IEEE80211_STYPE_DISASSOC, req->reason_code,

2568

IEEE80211_STYPE_DISASSOC, req->reason_code,

2570

cookie);

2569

cookie);

2571

return 0;

2570

return 0;

2572

}

2571

}

2573

2572

GITLAB

mac80211: keep auth state when assoc fails

 /*
  * BSS client mode implementation
  * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
  * Copyright 2004, Instant802 Networks, Inc.
  * Copyright 2005, Devicescape Software, Inc.
  * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
  * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/delay.h>
 #include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/if_arp.h>
 #include <linux/etherdevice.h>
 #include <linux/rtnetlink.h>
 #include <linux/pm_qos_params.h>
 #include <linux/crc32.h>
 #include <net/mac80211.h>
 #include <asm/unaligned.h>
 #include "ieee80211_i.h"
 #include "driver-ops.h"
 #include "rate.h"
 #include "led.h"
 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
 #define IEEE80211_AUTH_MAX_TRIES 3
 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
 #define IEEE80211_ASSOC_MAX_TRIES 3
 #define IEEE80211_MAX_PROBE_TRIES 5
 /*
  * beacon loss detection timeout
  * XXX: should depend on beacon interval
  */
 #define IEEE80211_BEACON_LOSS_TIME	(2 * HZ)
 /*
  * Time the connection can be idle before we probe
  * it to see if we can still talk to the AP.
  */
 #define IEEE80211_CONNECTION_IDLE_TIME	(30 * HZ)
 /*
  * Time we wait for a probe response after sending
  * a probe request because of beacon loss or for
  * checking the connection still works.
  */
 #define IEEE80211_PROBE_WAIT		(HZ / 2)
 #define TMR_RUNNING_TIMER	0
 #define TMR_RUNNING_CHANSW	1
 /*
  * All cfg80211 functions have to be called outside a locked
  * section so that they can acquire a lock themselves... This
  * is much simpler than queuing up things in cfg80211, but we
  * do need some indirection for that here.
  */
 enum rx_mgmt_action {
 	/* no action required */
 	RX_MGMT_NONE,
 	/* caller must call cfg80211_send_rx_auth() */
 	RX_MGMT_CFG80211_AUTH,
 	/* caller must call cfg80211_send_rx_assoc() */
 	RX_MGMT_CFG80211_ASSOC,
 	/* caller must call cfg80211_send_deauth() */
 	RX_MGMT_CFG80211_DEAUTH,
 	/* caller must call cfg80211_send_disassoc() */
 	RX_MGMT_CFG80211_DISASSOC,
 	/* caller must call cfg80211_auth_timeout() & free work */
 	RX_MGMT_CFG80211_AUTH_TO,
 	/* caller must call cfg80211_assoc_timeout() & free work */
 	RX_MGMT_CFG80211_ASSOC_TO,
 };
 /* utils */
 static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)
 {
 	WARN_ON(!mutex_is_locked(&ifmgd->mtx));
 }
 /*
  * We can have multiple work items (and connection probing)
  * scheduling this timer, but we need to take care to only
  * reschedule it when it should fire _earlier_ than it was
  * asked for before, or if it's not pending right now. This
  * function ensures that. Note that it then is required to
  * run this function for all timeouts after the first one
  * has happened -- the work that runs from this timer will
  * do that.
  */
 static void run_again(struct ieee80211_if_managed *ifmgd,
 			     unsigned long timeout)
 {
 	ASSERT_MGD_MTX(ifmgd);
 	if (!timer_pending(&ifmgd->timer) ||
 	    time_before(timeout, ifmgd->timer.expires))
 		mod_timer(&ifmgd->timer, timeout);
 }
 static void mod_beacon_timer(struct ieee80211_sub_if_data *sdata)
 {
 	if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER)
 		return;
 	mod_timer(&sdata->u.mgd.bcn_mon_timer,
 		  round_jiffies_up(jiffies + IEEE80211_BEACON_LOSS_TIME));
 }
 static int ecw2cw(int ecw)
 {
 	return (1 << ecw) - 1;
 }
 static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
 				      struct ieee80211_supported_band *sband,
 				      u32 *rates)
 {
 	int i, j, count;
 	*rates = 0;
 	count = 0;
 	for (i = 0; i < bss->supp_rates_len; i++) {
 		int rate = (bss->supp_rates[i] & 0x7F) * 5;
 		for (j = 0; j < sband->n_bitrates; j++)
 			if (sband->bitrates[j].bitrate == rate) {
 				*rates |= BIT(j);
 				count++;
 				break;
 			}
 	}
 	return count;
 }
 /*
  * ieee80211_enable_ht should be called only after the operating band
  * has been determined as ht configuration depends on the hw's
  * HT abilities for a specific band.
  */
 static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
 			       struct ieee80211_ht_info *hti,
 			       const u8 *bssid, u16 ap_ht_cap_flags)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_supported_band *sband;
 	struct sta_info *sta;
 	u32 changed = 0;
 	u16 ht_opmode;
 	bool enable_ht = true, ht_changed;
 	enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	/* HT is not supported */
 	if (!sband->ht_cap.ht_supported)
 		enable_ht = false;
 	/* check that channel matches the right operating channel */
 	if (local->hw.conf.channel->center_freq !=
 	    ieee80211_channel_to_frequency(hti->control_chan))
 		enable_ht = false;
 	if (enable_ht) {
 		channel_type = NL80211_CHAN_HT20;
 		if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
 		    (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
 		    (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
 			switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
 			case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
 				if (!(local->hw.conf.channel->flags &
 				    IEEE80211_CHAN_NO_HT40PLUS))
 					channel_type = NL80211_CHAN_HT40PLUS;
 				break;
 			case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
 				if (!(local->hw.conf.channel->flags &
 				    IEEE80211_CHAN_NO_HT40MINUS))
 					channel_type = NL80211_CHAN_HT40MINUS;
 				break;
 			}
 		}
 	}
 	ht_changed = conf_is_ht(&local->hw.conf) != enable_ht ||
 		     channel_type != local->hw.conf.channel_type;
 	local->oper_channel_type = channel_type;
 	if (ht_changed) {
                 /* channel_type change automatically detected */
 		ieee80211_hw_config(local, 0);
 		rcu_read_lock();
 		sta = sta_info_get(local, bssid);
 		if (sta)
 			rate_control_rate_update(local, sband, sta,
 						 IEEE80211_RC_HT_CHANGED);
 		rcu_read_unlock();
         }
 	/* disable HT */
 	if (!enable_ht)
 		return 0;
 	ht_opmode = le16_to_cpu(hti->operation_mode);
 	/* if bss configuration changed store the new one */
 	if (!sdata->ht_opmode_valid ||
 	    sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
 		changed |= BSS_CHANGED_HT;
 		sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
 		sdata->ht_opmode_valid = true;
 	}
 	return changed;
 }
 /* frame sending functions */
 static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
 				 struct ieee80211_mgd_work *wk)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *mgmt;
 	u8 *pos;
 	const u8 *ies, *ht_ie;
 	int i, len, count, rates_len, supp_rates_len;
 	u16 capab;
 	int wmm = 0;
 	struct ieee80211_supported_band *sband;
 	u32 rates = 0;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom +
 			    sizeof(*mgmt) + 200 + wk->ie_len +
 			    wk->ssid_len);
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
 		       "frame\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	capab = ifmgd->capab;
 	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
 		if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
 			capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
 		if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
 			capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
 	}
 	if (wk->bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)
 		capab |= WLAN_CAPABILITY_PRIVACY;
 	if (wk->bss->wmm_used)
 		wmm = 1;
 	/* get all rates supported by the device and the AP as
 	 * some APs don't like getting a superset of their rates
 	 * in the association request (e.g. D-Link DAP 1353 in
 	 * b-only mode) */
 	rates_len = ieee80211_compatible_rates(wk->bss, sband, &rates);
 	if ((wk->bss->cbss.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
 	    (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
 		capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
 	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 	memset(mgmt, 0, 24);
 	memcpy(mgmt->da, wk->bss->cbss.bssid, ETH_ALEN);
 	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 	memcpy(mgmt->bssid, wk->bss->cbss.bssid, ETH_ALEN);
 	if (!is_zero_ether_addr(wk->prev_bssid)) {
 		skb_put(skb, 10);
 		mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 						  IEEE80211_STYPE_REASSOC_REQ);
 		mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
 		mgmt->u.reassoc_req.listen_interval =
 				cpu_to_le16(local->hw.conf.listen_interval);
 		memcpy(mgmt->u.reassoc_req.current_ap, wk->prev_bssid,
 		       ETH_ALEN);
 	} else {
 		skb_put(skb, 4);
 		mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 						  IEEE80211_STYPE_ASSOC_REQ);
 		mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
 		mgmt->u.assoc_req.listen_interval =
 				cpu_to_le16(local->hw.conf.listen_interval);
 	}
 	/* SSID */
 	ies = pos = skb_put(skb, 2 + wk->ssid_len);
 	*pos++ = WLAN_EID_SSID;
 	*pos++ = wk->ssid_len;
 	memcpy(pos, wk->ssid, wk->ssid_len);
 	/* add all rates which were marked to be used above */
 	supp_rates_len = rates_len;
 	if (supp_rates_len > 8)
 		supp_rates_len = 8;
 	len = sband->n_bitrates;
 	pos = skb_put(skb, supp_rates_len + 2);
 	*pos++ = WLAN_EID_SUPP_RATES;
 	*pos++ = supp_rates_len;
 	count = 0;
 	for (i = 0; i < sband->n_bitrates; i++) {
 		if (BIT(i) & rates) {
 			int rate = sband->bitrates[i].bitrate;
 			*pos++ = (u8) (rate / 5);
 			if (++count == 8)
 				break;
 		}
 	}
 	if (rates_len > count) {
 		pos = skb_put(skb, rates_len - count + 2);
 		*pos++ = WLAN_EID_EXT_SUPP_RATES;
 		*pos++ = rates_len - count;
 		for (i++; i < sband->n_bitrates; i++) {
 			if (BIT(i) & rates) {
 				int rate = sband->bitrates[i].bitrate;
 				*pos++ = (u8) (rate / 5);
 			}
 		}
 	}
 	if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
 		/* 1. power capabilities */
 		pos = skb_put(skb, 4);
 		*pos++ = WLAN_EID_PWR_CAPABILITY;
 		*pos++ = 2;
 		*pos++ = 0; /* min tx power */
 		*pos++ = local->hw.conf.channel->max_power; /* max tx power */
 		/* 2. supported channels */
 		/* TODO: get this in reg domain format */
 		pos = skb_put(skb, 2 * sband->n_channels + 2);
 		*pos++ = WLAN_EID_SUPPORTED_CHANNELS;
 		*pos++ = 2 * sband->n_channels;
 		for (i = 0; i < sband->n_channels; i++) {
 			*pos++ = ieee80211_frequency_to_channel(
 					sband->channels[i].center_freq);
 			*pos++ = 1; /* one channel in the subband*/
 		}
 	}
 	if (wk->ie_len && wk->ie) {
 		pos = skb_put(skb, wk->ie_len);
 		memcpy(pos, wk->ie, wk->ie_len);
 	}
 	if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {
 		pos = skb_put(skb, 9);
 		*pos++ = WLAN_EID_VENDOR_SPECIFIC;
 		*pos++ = 7; /* len */
 		*pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
 		*pos++ = 0x50;
 		*pos++ = 0xf2;
 		*pos++ = 2; /* WME */
 		*pos++ = 0; /* WME info */
 		*pos++ = 1; /* WME ver */
 		*pos++ = 0;
 	}
 	/* wmm support is a must to HT */
 	/*
 	 * IEEE802.11n does not allow TKIP/WEP as pairwise
 	 * ciphers in HT mode. We still associate in non-ht
 	 * mode (11a/b/g) if any one of these ciphers is
 	 * configured as pairwise.
 	 */
 	if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
 	    sband->ht_cap.ht_supported &&
 	    (ht_ie = ieee80211_bss_get_ie(&wk->bss->cbss, WLAN_EID_HT_INFORMATION)) &&
 	    ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&
 	    (!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))) {
 		struct ieee80211_ht_info *ht_info =
 			(struct ieee80211_ht_info *)(ht_ie + 2);
 		u16 cap = sband->ht_cap.cap;
 		__le16 tmp;
 		u32 flags = local->hw.conf.channel->flags;
 		switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
 		case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
 			if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
 				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 				cap &= ~IEEE80211_HT_CAP_SGI_40;
 			}
 			break;
 		case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
 			if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
 				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 				cap &= ~IEEE80211_HT_CAP_SGI_40;
 			}
 			break;
 		}
 		tmp = cpu_to_le16(cap);
 		pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);
 		*pos++ = WLAN_EID_HT_CAPABILITY;
 		*pos++ = sizeof(struct ieee80211_ht_cap);
 		memset(pos, 0, sizeof(struct ieee80211_ht_cap));
 		memcpy(pos, &tmp, sizeof(u16));
 		pos += sizeof(u16);
 		/* TODO: needs a define here for << 2 */
 		*pos++ = sband->ht_cap.ampdu_factor |
 			 (sband->ht_cap.ampdu_density << 2);
 		memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
 	}
 	ieee80211_tx_skb(sdata, skb, 0);
 }
 static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
 					   const u8 *bssid, u16 stype, u16 reason,
 					   void *cookie)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *mgmt;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for "
 		       "deauth/disassoc frame\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 	memset(mgmt, 0, 24);
 	memcpy(mgmt->da, bssid, ETH_ALEN);
 	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 	memcpy(mgmt->bssid, bssid, ETH_ALEN);
 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
 	skb_put(skb, 2);
 	/* u.deauth.reason_code == u.disassoc.reason_code */
 	mgmt->u.deauth.reason_code = cpu_to_le16(reason);
 	if (stype == IEEE80211_STYPE_DEAUTH)
 		cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, cookie);
 	else
 		cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len, cookie);
 	ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);
 }
 void ieee80211_send_pspoll(struct ieee80211_local *local,
 			   struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_pspoll *pspoll;
 	struct sk_buff *skb;
 	u16 fc;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for "
 		       "pspoll frame\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
 	memset(pspoll, 0, sizeof(*pspoll));
 	fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;
 	pspoll->frame_control = cpu_to_le16(fc);
 	pspoll->aid = cpu_to_le16(ifmgd->aid);
 	/* aid in PS-Poll has its two MSBs each set to 1 */
 	pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
 	memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
 	memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);
 	ieee80211_tx_skb(sdata, skb, 0);
 }
 void ieee80211_send_nullfunc(struct ieee80211_local *local,
 			     struct ieee80211_sub_if_data *sdata,
 			     int powersave)
 {
 	struct sk_buff *skb;
 	struct ieee80211_hdr *nullfunc;
 	__le16 fc;
 	if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
 		return;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
 		       "frame\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
 	memset(nullfunc, 0, 24);
 	fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
 			 IEEE80211_FCTL_TODS);
 	if (powersave)
 		fc |= cpu_to_le16(IEEE80211_FCTL_PM);
 	nullfunc->frame_control = fc;
 	memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
 	memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
 	memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
 	ieee80211_tx_skb(sdata, skb, 0);
 }
 /* spectrum management related things */
 static void ieee80211_chswitch_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	if (!netif_running(sdata->dev))
 		return;
 	mutex_lock(&ifmgd->mtx);
 	if (!ifmgd->associated)
 		goto out;
 	sdata->local->oper_channel = sdata->local->csa_channel;
 	ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL);
 	/* XXX: shouldn't really modify cfg80211-owned data! */
 	ifmgd->associated->cbss.channel = sdata->local->oper_channel;
 	ieee80211_wake_queues_by_reason(&sdata->local->hw,
 					IEEE80211_QUEUE_STOP_REASON_CSA);
  out:
 	ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
 	mutex_unlock(&ifmgd->mtx);
 }
 static void ieee80211_chswitch_timer(unsigned long data)
 {
 	struct ieee80211_sub_if_data *sdata =
 		(struct ieee80211_sub_if_data *) data;
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	if (sdata->local->quiescing) {
 		set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
 		return;
 	}
 	ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
 }
 void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
 				      struct ieee80211_channel_sw_ie *sw_elem,
 				      struct ieee80211_bss *bss)
 {
 	struct ieee80211_channel *new_ch;
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);
 	ASSERT_MGD_MTX(ifmgd);
 	if (!ifmgd->associated)
 		return;
 	if (sdata->local->scanning)
 		return;
 	/* Disregard subsequent beacons if we are already running a timer
 	   processing a CSA */
 	if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
 		return;
 	new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
 	if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
 		return;
 	sdata->local->csa_channel = new_ch;
 	if (sw_elem->count <= 1) {
 		ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
 	} else {
 		ieee80211_stop_queues_by_reason(&sdata->local->hw,
 					IEEE80211_QUEUE_STOP_REASON_CSA);
 		ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
 		mod_timer(&ifmgd->chswitch_timer,
 			  jiffies +
 			  msecs_to_jiffies(sw_elem->count *
 					   bss->cbss.beacon_interval));
 	}
 }
 static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
 					u16 capab_info, u8 *pwr_constr_elem,
 					u8 pwr_constr_elem_len)
 {
 	struct ieee80211_conf *conf = &sdata->local->hw.conf;
 	if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
 		return;
 	/* Power constraint IE length should be 1 octet */
 	if (pwr_constr_elem_len != 1)
 		return;
 	if ((*pwr_constr_elem <= conf->channel->max_power) &&
 	    (*pwr_constr_elem != sdata->local->power_constr_level)) {
 		sdata->local->power_constr_level = *pwr_constr_elem;
 		ieee80211_hw_config(sdata->local, 0);
 	}
 }
 /* powersave */
 static void ieee80211_enable_ps(struct ieee80211_local *local,
 				struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_conf *conf = &local->hw.conf;
 	/*
 	 * If we are scanning right now then the parameters will
 	 * take effect when scan finishes.
 	 */
 	if (local->scanning)
 		return;
 	if (conf->dynamic_ps_timeout > 0 &&
 	    !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
 		mod_timer(&local->dynamic_ps_timer, jiffies +
 			  msecs_to_jiffies(conf->dynamic_ps_timeout));
 	} else {
 		if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
 			ieee80211_send_nullfunc(local, sdata, 1);
 		conf->flags |= IEEE80211_CONF_PS;
 		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
 	}
 }
 static void ieee80211_change_ps(struct ieee80211_local *local)
 {
 	struct ieee80211_conf *conf = &local->hw.conf;
 	if (local->ps_sdata) {
 		ieee80211_enable_ps(local, local->ps_sdata);
 	} else if (conf->flags & IEEE80211_CONF_PS) {
 		conf->flags &= ~IEEE80211_CONF_PS;
 		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
 		del_timer_sync(&local->dynamic_ps_timer);
 		cancel_work_sync(&local->dynamic_ps_enable_work);
 	}
 }
 /* need to hold RTNL or interface lock */
 void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
 {
 	struct ieee80211_sub_if_data *sdata, *found = NULL;
 	int count = 0;
 	if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
 		local->ps_sdata = NULL;
 		return;
 	}
 	list_for_each_entry(sdata, &local->interfaces, list) {
 		if (!netif_running(sdata->dev))
 			continue;
 		if (sdata->vif.type != NL80211_IFTYPE_STATION)
 			continue;
 		found = sdata;
 		count++;
 	}
 	if (count == 1 && found->u.mgd.powersave &&
 	    found->u.mgd.associated && list_empty(&found->u.mgd.work_list) &&
 	    !(found->u.mgd.flags & (IEEE80211_STA_BEACON_POLL |
 				    IEEE80211_STA_CONNECTION_POLL))) {
 		s32 beaconint_us;
 		if (latency < 0)
 			latency = pm_qos_requirement(PM_QOS_NETWORK_LATENCY);
 		beaconint_us = ieee80211_tu_to_usec(
 					found->vif.bss_conf.beacon_int);
 		if (beaconint_us > latency) {
 			local->ps_sdata = NULL;
 		} else {
 			u8 dtimper = found->vif.bss_conf.dtim_period;
 			int maxslp = 1;
 			if (dtimper > 1)
 				maxslp = min_t(int, dtimper,
 						    latency / beaconint_us);
 			local->hw.conf.max_sleep_period = maxslp;
 			local->ps_sdata = found;
 		}
 	} else {
 		local->ps_sdata = NULL;
 	}
 	ieee80211_change_ps(local);
 }
 void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
 {
 	struct ieee80211_local *local =
 		container_of(work, struct ieee80211_local,
 			     dynamic_ps_disable_work);
 	if (local->hw.conf.flags & IEEE80211_CONF_PS) {
 		local->hw.conf.flags &= ~IEEE80211_CONF_PS;
 		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
 	}
 	ieee80211_wake_queues_by_reason(&local->hw,
 					IEEE80211_QUEUE_STOP_REASON_PS);
 }
 void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
 {
 	struct ieee80211_local *local =
 		container_of(work, struct ieee80211_local,
 			     dynamic_ps_enable_work);
 	struct ieee80211_sub_if_data *sdata = local->ps_sdata;
 	/* can only happen when PS was just disabled anyway */
 	if (!sdata)
 		return;
 	if (local->hw.conf.flags & IEEE80211_CONF_PS)
 		return;
 	if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
 		ieee80211_send_nullfunc(local, sdata, 1);
 	local->hw.conf.flags |= IEEE80211_CONF_PS;
 	ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
 }
 void ieee80211_dynamic_ps_timer(unsigned long data)
 {
 	struct ieee80211_local *local = (void *) data;
 	if (local->quiescing || local->suspended)
 		return;
 	ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
 }
 /* MLME */
 static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
 				     struct ieee80211_if_managed *ifmgd,
 				     u8 *wmm_param, size_t wmm_param_len)
 {
 	struct ieee80211_tx_queue_params params;
 	size_t left;
 	int count;
 	u8 *pos;
 	if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))
 		return;
 	if (!wmm_param)
 		return;
 	if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
 		return;
 	count = wmm_param[6] & 0x0f;
 	if (count == ifmgd->wmm_last_param_set)
 		return;
 	ifmgd->wmm_last_param_set = count;
 	pos = wmm_param + 8;
 	left = wmm_param_len - 8;
 	memset(&params, 0, sizeof(params));
 	local->wmm_acm = 0;
 	for (; left >= 4; left -= 4, pos += 4) {
 		int aci = (pos[0] >> 5) & 0x03;
 		int acm = (pos[0] >> 4) & 0x01;
 		int queue;
 		switch (aci) {
 		case 1: /* AC_BK */
 			queue = 3;
 			if (acm)
 				local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
 			break;
 		case 2: /* AC_VI */
 			queue = 1;
 			if (acm)
 				local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
 			break;
 		case 3: /* AC_VO */
 			queue = 0;
 			if (acm)
 				local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
 			break;
 		case 0: /* AC_BE */
 		default:
 			queue = 2;
 			if (acm)
 				local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
 			break;
 		}
 		params.aifs = pos[0] & 0x0f;
 		params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
 		params.cw_min = ecw2cw(pos[1] & 0x0f);
 		params.txop = get_unaligned_le16(pos + 2);
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 		printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
 		       "cWmin=%d cWmax=%d txop=%d\n",
 		       wiphy_name(local->hw.wiphy), queue, aci, acm,
 		       params.aifs, params.cw_min, params.cw_max, params.txop);
 #endif
 		if (drv_conf_tx(local, queue, &params) && local->ops->conf_tx)
 			printk(KERN_DEBUG "%s: failed to set TX queue "
 			       "parameters for queue %d\n",
 			       wiphy_name(local->hw.wiphy), queue);
 	}
 }
 static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
 					   u16 capab, bool erp_valid, u8 erp)
 {
 	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
 	u32 changed = 0;
 	bool use_protection;
 	bool use_short_preamble;
 	bool use_short_slot;
 	if (erp_valid) {
 		use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
 		use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
 	} else {
 		use_protection = false;
 		use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
 	}
 	use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
 	if (use_protection != bss_conf->use_cts_prot) {
 		bss_conf->use_cts_prot = use_protection;
 		changed |= BSS_CHANGED_ERP_CTS_PROT;
 	}
 	if (use_short_preamble != bss_conf->use_short_preamble) {
 		bss_conf->use_short_preamble = use_short_preamble;
 		changed |= BSS_CHANGED_ERP_PREAMBLE;
 	}
 	if (use_short_slot != bss_conf->use_short_slot) {
 		bss_conf->use_short_slot = use_short_slot;
 		changed |= BSS_CHANGED_ERP_SLOT;
 	}
 	return changed;
 }
 static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_mgd_work *wk,
 				     u32 bss_info_changed)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_bss *bss = wk->bss;
 	bss_info_changed |= BSS_CHANGED_ASSOC;
 	/* set timing information */
 	sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;
 	sdata->vif.bss_conf.timestamp = bss->cbss.tsf;
 	sdata->vif.bss_conf.dtim_period = bss->dtim_period;
 	bss_info_changed |= BSS_CHANGED_BEACON_INT;
 	bss_info_changed |= ieee80211_handle_bss_capability(sdata,
 		bss->cbss.capability, bss->has_erp_value, bss->erp_value);
 	sdata->u.mgd.associated = bss;
 	sdata->u.mgd.old_associate_work = wk;
 	memcpy(sdata->u.mgd.bssid, bss->cbss.bssid, ETH_ALEN);
 	/* just to be sure */
 	sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
 				IEEE80211_STA_BEACON_POLL);
 	ieee80211_led_assoc(local, 1);
 	sdata->vif.bss_conf.assoc = 1;
 	/*
 	 * For now just always ask the driver to update the basic rateset
 	 * when we have associated, we aren't checking whether it actually
 	 * changed or not.
 	 */
 	bss_info_changed |= BSS_CHANGED_BASIC_RATES;
 	/* And the BSSID changed - we're associated now */
 	bss_info_changed |= BSS_CHANGED_BSSID;
 	ieee80211_bss_info_change_notify(sdata, bss_info_changed);
 	mutex_lock(&local->iflist_mtx);
 	ieee80211_recalc_ps(local, -1);
 	mutex_unlock(&local->iflist_mtx);
 	netif_tx_start_all_queues(sdata->dev);
 	netif_carrier_on(sdata->dev);
 }
 static enum rx_mgmt_action __must_check
 ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata,
 		       struct ieee80211_mgd_work *wk)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	wk->tries++;
 	if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
 		printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
 		       sdata->dev->name, wk->bss->cbss.bssid);
 		/*
 		 * Most likely AP is not in the range so remove the
 		 * bss struct for that AP.
 		 */
 		cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
 		/*
 		 * We might have a pending scan which had no chance to run yet
 		 * due to work needing to be done. Hence, queue the STAs work
 		 * again for that.
 		 */
 		ieee80211_queue_work(&local->hw, &ifmgd->work);
 		return RX_MGMT_CFG80211_AUTH_TO;
 	}
 	printk(KERN_DEBUG "%s: direct probe to AP %pM (try %d)\n",
 			sdata->dev->name, wk->bss->cbss.bssid,
 			wk->tries);
 	/*
 	 * Direct probe is sent to broadcast address as some APs
 	 * will not answer to direct packet in unassociated state.
 	 */
 	ieee80211_send_probe_req(sdata, NULL, wk->ssid, wk->ssid_len, NULL, 0);
 	wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
 	run_again(ifmgd, wk->timeout);
 	return RX_MGMT_NONE;
 }
 static enum rx_mgmt_action __must_check
 ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,
 		       struct ieee80211_mgd_work *wk)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	wk->tries++;
 	if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
 		printk(KERN_DEBUG "%s: authentication with AP %pM"
 		       " timed out\n",
 		       sdata->dev->name, wk->bss->cbss.bssid);
 		/*
 		 * Most likely AP is not in the range so remove the
 		 * bss struct for that AP.
 		 */
 		cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
 		/*
 		 * We might have a pending scan which had no chance to run yet
 		 * due to work needing to be done. Hence, queue the STAs work
 		 * again for that.
 		 */
 		ieee80211_queue_work(&local->hw, &ifmgd->work);
 		return RX_MGMT_CFG80211_AUTH_TO;
 	}
 	printk(KERN_DEBUG "%s: authenticate with AP %pM (try %d)\n",
 	       sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
 	ieee80211_send_auth(sdata, 1, wk->auth_alg, wk->ie, wk->ie_len,
 			    wk->bss->cbss.bssid, NULL, 0, 0);
 	wk->auth_transaction = 2;
 	wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
 	run_again(ifmgd, wk->timeout);
 	return RX_MGMT_NONE;
 }
 static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
 				   bool deauth)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	struct sta_info *sta;
 	u32 changed = 0, config_changed = 0;
 	u8 bssid[ETH_ALEN];
 	ASSERT_MGD_MTX(ifmgd);
 	if (WARN_ON(!ifmgd->associated))
 		return;
 	memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
 	ifmgd->associated = NULL;
 	memset(ifmgd->bssid, 0, ETH_ALEN);
 	if (deauth) {
 		kfree(ifmgd->old_associate_work);
 		ifmgd->old_associate_work = NULL;
 	} else {
 		struct ieee80211_mgd_work *wk = ifmgd->old_associate_work;
 		wk->state = IEEE80211_MGD_STATE_IDLE;
 		list_add(&wk->list, &ifmgd->work_list);
 	}
 	/*
 	 * we need to commit the associated = NULL change because the
 	 * scan code uses that to determine whether this iface should
 	 * go to/wake up from powersave or not -- and could otherwise
 	 * wake the queues erroneously.
 	 */
 	smp_mb();
 	/*
 	 * Thus, we can only afterwards stop the queues -- to account
 	 * for the case where another CPU is finishing a scan at this
 	 * time -- we don't want the scan code to enable queues.
 	 */
 	netif_tx_stop_all_queues(sdata->dev);
 	netif_carrier_off(sdata->dev);
 	rcu_read_lock();
 	sta = sta_info_get(local, bssid);
 	if (sta)
 		ieee80211_sta_tear_down_BA_sessions(sta);
 	rcu_read_unlock();
 	changed |= ieee80211_reset_erp_info(sdata);
 	ieee80211_led_assoc(local, 0);
 	changed |= BSS_CHANGED_ASSOC;
 	sdata->vif.bss_conf.assoc = false;
 	ieee80211_set_wmm_default(sdata);
 	ieee80211_recalc_idle(local);
 	/* channel(_type) changes are handled by ieee80211_hw_config */
 	local->oper_channel_type = NL80211_CHAN_NO_HT;
 	/* on the next assoc, re-program HT parameters */
 	sdata->ht_opmode_valid = false;
 	local->power_constr_level = 0;
 	del_timer_sync(&local->dynamic_ps_timer);
 	cancel_work_sync(&local->dynamic_ps_enable_work);
 	if (local->hw.conf.flags & IEEE80211_CONF_PS) {
 		local->hw.conf.flags &= ~IEEE80211_CONF_PS;
 		config_changed |= IEEE80211_CONF_CHANGE_PS;
 	}
 	ieee80211_hw_config(local, config_changed);
 	/* And the BSSID changed -- not very interesting here */
 	changed |= BSS_CHANGED_BSSID;
 	ieee80211_bss_info_change_notify(sdata, changed);
 	rcu_read_lock();
 	sta = sta_info_get(local, bssid);
 	if (!sta) {
 		rcu_read_unlock();
 		return;
 	}
 	sta_info_unlink(&sta);
 	rcu_read_unlock();
 	sta_info_destroy(sta);
 }
 static enum rx_mgmt_action __must_check
 ieee80211_associate(struct ieee80211_sub_if_data *sdata,
 		    struct ieee80211_mgd_work *wk)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	wk->tries++;
 	if (wk->tries > IEEE80211_ASSOC_MAX_TRIES) {
 		printk(KERN_DEBUG "%s: association with AP %pM"
 		       " timed out\n",
 		       sdata->dev->name, wk->bss->cbss.bssid);
 		/*
 		 * Most likely AP is not in the range so remove the
 		 * bss struct for that AP.
 		 */
 		cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
 		/*
 		 * We might have a pending scan which had no chance to run yet
 		 * due to work needing to be done. Hence, queue the STAs work
 		 * again for that.
 		 */
 		ieee80211_queue_work(&local->hw, &ifmgd->work);
 		return RX_MGMT_CFG80211_ASSOC_TO;
 	}
 	printk(KERN_DEBUG "%s: associate with AP %pM (try %d)\n",
 	       sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
 	ieee80211_send_assoc(sdata, wk);
 	wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
 	run_again(ifmgd, wk->timeout);
 	return RX_MGMT_NONE;
 }
 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
 			     struct ieee80211_hdr *hdr)
 {
 	/*
 	 * We can postpone the mgd.timer whenever receiving unicast frames
 	 * from AP because we know that the connection is working both ways
 	 * at that time. But multicast frames (and hence also beacons) must
 	 * be ignored here, because we need to trigger the timer during
 	 * data idle periods for sending the periodic probe request to the
 	 * AP we're connected to.
 	 */
 	if (is_multicast_ether_addr(hdr->addr1))
 		return;
 	mod_timer(&sdata->u.mgd.conn_mon_timer,
 		  round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
 }
 static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	const u8 *ssid;
 	ssid = ieee80211_bss_get_ie(&ifmgd->associated->cbss, WLAN_EID_SSID);
 	ieee80211_send_probe_req(sdata, ifmgd->associated->cbss.bssid,
 				 ssid + 2, ssid[1], NULL, 0);
 	ifmgd->probe_send_count++;
 	ifmgd->probe_timeout = jiffies + IEEE80211_PROBE_WAIT;
 	run_again(ifmgd, ifmgd->probe_timeout);
 }
 static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
 				   bool beacon)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	bool already = false;
 	if (!netif_running(sdata->dev))
 		return;
 	if (sdata->local->scanning)
 		return;
 	mutex_lock(&ifmgd->mtx);
 	if (!ifmgd->associated)
 		goto out;
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	if (beacon && net_ratelimit())
 		printk(KERN_DEBUG "%s: detected beacon loss from AP "
 		       "- sending probe request\n", sdata->dev->name);
 #endif
 	/*
 	 * The driver/our work has already reported this event or the
 	 * connection monitoring has kicked in and we have already sent
 	 * a probe request. Or maybe the AP died and the driver keeps
 	 * reporting until we disassociate...
 	 *
 	 * In either case we have to ignore the current call to this
 	 * function (except for setting the correct probe reason bit)
 	 * because otherwise we would reset the timer every time and
 	 * never check whether we received a probe response!
 	 */
 	if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
 			    IEEE80211_STA_CONNECTION_POLL))
 		already = true;
 	if (beacon)
 		ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
 	else
 		ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
 	if (already)
 		goto out;
 	mutex_lock(&sdata->local->iflist_mtx);
 	ieee80211_recalc_ps(sdata->local, -1);
 	mutex_unlock(&sdata->local->iflist_mtx);
 	ifmgd->probe_send_count = 0;
 	ieee80211_mgd_probe_ap_send(sdata);
  out:
 	mutex_unlock(&ifmgd->mtx);
 }
 void ieee80211_beacon_loss_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data,
 			     u.mgd.beacon_loss_work);
 	ieee80211_mgd_probe_ap(sdata, true);
 }
 void ieee80211_beacon_loss(struct ieee80211_vif *vif)
 {
 	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 	ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);
 }
 EXPORT_SYMBOL(ieee80211_beacon_loss);
 static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_mgd_work *wk)
 {
 	wk->state = IEEE80211_MGD_STATE_IDLE;
 	printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
 }
 static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_mgd_work *wk,
 				     struct ieee80211_mgmt *mgmt,
 				     size_t len)
 {
 	u8 *pos;
 	struct ieee802_11_elems elems;
 	pos = mgmt->u.auth.variable;
 	ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
 	if (!elems.challenge)
 		return;
 	ieee80211_send_auth(sdata, 3, wk->auth_alg,
 			    elems.challenge - 2, elems.challenge_len + 2,
 			    wk->bss->cbss.bssid,
 			    wk->key, wk->key_len, wk->key_idx);
 	wk->auth_transaction = 4;
 }
 static enum rx_mgmt_action __must_check
 ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
 		       struct ieee80211_mgd_work *wk,
 		       struct ieee80211_mgmt *mgmt, size_t len)
 {
 	u16 auth_alg, auth_transaction, status_code;
 	if (wk->state != IEEE80211_MGD_STATE_AUTH)
 		return RX_MGMT_NONE;
 	if (len < 24 + 6)
 		return RX_MGMT_NONE;
 	if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
 		return RX_MGMT_NONE;
 	if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
 		return RX_MGMT_NONE;
 	auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
 	auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
 	status_code = le16_to_cpu(mgmt->u.auth.status_code);
 	if (auth_alg != wk->auth_alg ||
 	    auth_transaction != wk->auth_transaction)
 		return RX_MGMT_NONE;
 	if (status_code != WLAN_STATUS_SUCCESS) {
 		list_del(&wk->list);
 		kfree(wk);
 		return RX_MGMT_CFG80211_AUTH;
 	}
 	switch (wk->auth_alg) {
 	case WLAN_AUTH_OPEN:
 	case WLAN_AUTH_LEAP:
 	case WLAN_AUTH_FT:
 		ieee80211_auth_completed(sdata, wk);
 		return RX_MGMT_CFG80211_AUTH;
 	case WLAN_AUTH_SHARED_KEY:
 		if (wk->auth_transaction == 4) {
 			ieee80211_auth_completed(sdata, wk);
 			return RX_MGMT_CFG80211_AUTH;
 		} else
 			ieee80211_auth_challenge(sdata, wk, mgmt, len);
 		break;
 	}
 	return RX_MGMT_NONE;
 }
 static enum rx_mgmt_action __must_check
 ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
 			 struct ieee80211_mgd_work *wk,
 			 struct ieee80211_mgmt *mgmt, size_t len)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	const u8 *bssid = NULL;
 	u16 reason_code;
 	if (len < 24 + 2)
 		return RX_MGMT_NONE;
 	ASSERT_MGD_MTX(ifmgd);
 	if (wk)
 		bssid = wk->bss->cbss.bssid;
 	else
 		bssid = ifmgd->associated->cbss.bssid;
 	reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
 	printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
 			sdata->dev->name, bssid, reason_code);
 	if (!wk) {
 		ieee80211_set_disassoc(sdata, true);
 	} else {
 		list_del(&wk->list);
 		kfree(wk);
 	}
 	return RX_MGMT_CFG80211_DEAUTH;
 }
 static enum rx_mgmt_action __must_check
 ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
 			   struct ieee80211_mgmt *mgmt, size_t len)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	u16 reason_code;
 	if (len < 24 + 2)
 		return RX_MGMT_NONE;
 	ASSERT_MGD_MTX(ifmgd);
 	if (WARN_ON(!ifmgd->associated))
 		return RX_MGMT_NONE;
 	if (WARN_ON(memcmp(ifmgd->associated->cbss.bssid, mgmt->sa, ETH_ALEN)))
 		return RX_MGMT_NONE;
 	reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
 	printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
 			sdata->dev->name, mgmt->sa, reason_code);
 	ieee80211_set_disassoc(sdata, false);
 	return RX_MGMT_CFG80211_DISASSOC;
 }
 static enum rx_mgmt_action __must_check
 ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
 			     struct ieee80211_mgd_work *wk,
 			     struct ieee80211_mgmt *mgmt, size_t len,
 			     bool reassoc)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_supported_band *sband;
 	struct sta_info *sta;
 	u32 rates, basic_rates;
 	u16 capab_info, status_code, aid;
 	struct ieee802_11_elems elems;
 	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
 	u8 *pos;
 	u32 changed = 0;
 	int i, j;
 	bool have_higher_than_11mbit = false, newsta = false;
 	u16 ap_ht_cap_flags;
 	/*
 	 * AssocResp and ReassocResp have identical structure, so process both
 	 * of them in this function.
 	 */
 	if (len < 24 + 6)
 		return RX_MGMT_NONE;
 	if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
 		return RX_MGMT_NONE;
 	capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
 	status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
 	aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
 	printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
 	       "status=%d aid=%d)\n",
 	       sdata->dev->name, reassoc ? "Rea" : "A", mgmt->sa,
 	       capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
 	pos = mgmt->u.assoc_resp.variable;
 	ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
 	if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
 	    elems.timeout_int && elems.timeout_int_len == 5 &&
 	    elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
 		u32 tu, ms;
 		tu = get_unaligned_le32(elems.timeout_int + 1);
 		ms = tu * 1024 / 1000;
 		printk(KERN_DEBUG "%s: AP rejected association temporarily; "
 		       "comeback duration %u TU (%u ms)\n",
 		       sdata->dev->name, tu, ms);
 		wk->timeout = jiffies + msecs_to_jiffies(ms);
 		if (ms > IEEE80211_ASSOC_TIMEOUT)
 			run_again(ifmgd, jiffies + msecs_to_jiffies(ms));
 		return RX_MGMT_NONE;
 	}
 	if (status_code != WLAN_STATUS_SUCCESS) {
 		printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",
 		       sdata->dev->name, status_code);
-		list_del(&wk->list);
+		wk->state = IEEE80211_MGD_STATE_IDLE;
-		kfree(wk);
 		return RX_MGMT_CFG80211_ASSOC;
 	}
 	if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
 		printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
 		       "set\n", sdata->dev->name, aid);
 	aid &= ~(BIT(15) | BIT(14));
 	if (!elems.supp_rates) {
 		printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
 		       sdata->dev->name);
 		return RX_MGMT_NONE;
 	}
 	printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);
 	ifmgd->aid = aid;
 	rcu_read_lock();
 	/* Add STA entry for the AP */
 	sta = sta_info_get(local, wk->bss->cbss.bssid);
 	if (!sta) {
 		newsta = true;
 		rcu_read_unlock();
 		sta = sta_info_alloc(sdata, wk->bss->cbss.bssid, GFP_KERNEL);
 		if (!sta) {
 			printk(KERN_DEBUG "%s: failed to alloc STA entry for"
 			       " the AP\n", sdata->dev->name);
 			return RX_MGMT_NONE;
 		}
 		set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC |
 				   WLAN_STA_ASSOC_AP);
 		if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
 			set_sta_flags(sta, WLAN_STA_AUTHORIZED);
 		rcu_read_lock();
 	}
 	rates = 0;
 	basic_rates = 0;
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	for (i = 0; i < elems.supp_rates_len; i++) {
 		int rate = (elems.supp_rates[i] & 0x7f) * 5;
 		bool is_basic = !!(elems.supp_rates[i] & 0x80);
 		if (rate > 110)
 			have_higher_than_11mbit = true;
 		for (j = 0; j < sband->n_bitrates; j++) {
 			if (sband->bitrates[j].bitrate == rate) {
 				rates |= BIT(j);
 				if (is_basic)
 					basic_rates |= BIT(j);
 				break;
 			}
 		}
 	}
 	for (i = 0; i < elems.ext_supp_rates_len; i++) {
 		int rate = (elems.ext_supp_rates[i] & 0x7f) * 5;
 		bool is_basic = !!(elems.ext_supp_rates[i] & 0x80);
 		if (rate > 110)
 			have_higher_than_11mbit = true;
 		for (j = 0; j < sband->n_bitrates; j++) {
 			if (sband->bitrates[j].bitrate == rate) {
 				rates |= BIT(j);
 				if (is_basic)
 					basic_rates |= BIT(j);
 				break;
 			}
 		}
 	}
 	sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
 	sdata->vif.bss_conf.basic_rates = basic_rates;
 	/* cf. IEEE 802.11 9.2.12 */
 	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
 	    have_higher_than_11mbit)
 		sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
 	else
 		sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
 	if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
 		ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
 				elems.ht_cap_elem, &sta->sta.ht_cap);
 	ap_ht_cap_flags = sta->sta.ht_cap.cap;
 	rate_control_rate_init(sta);
 	if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
 		set_sta_flags(sta, WLAN_STA_MFP);
 	if (elems.wmm_param)
 		set_sta_flags(sta, WLAN_STA_WME);
 	if (newsta) {
 		int err = sta_info_insert(sta);
 		if (err) {
 			printk(KERN_DEBUG "%s: failed to insert STA entry for"
 			       " the AP (error %d)\n", sdata->dev->name, err);
 			rcu_read_unlock();
 			return RX_MGMT_NONE;
 		}
 	}
 	rcu_read_unlock();
 	if (elems.wmm_param)
 		ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
 					 elems.wmm_param_len);
 	else
 		ieee80211_set_wmm_default(sdata);
 	if (elems.ht_info_elem && elems.wmm_param &&
 	    (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
 	    !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
 		changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
 					       wk->bss->cbss.bssid,
 					       ap_ht_cap_flags);
         /* delete work item -- must be before set_associated for PS */
 	list_del(&wk->list);
 	/* set AID and assoc capability,
 	 * ieee80211_set_associated() will tell the driver */
 	bss_conf->aid = aid;
 	bss_conf->assoc_capability = capab_info;
 	/* this will take ownership of wk */
 	ieee80211_set_associated(sdata, wk, changed);
 	/*
 	 * Start timer to probe the connection to the AP now.
 	 * Also start the timer that will detect beacon loss.
 	 */
 	ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
 	mod_beacon_timer(sdata);
 	return RX_MGMT_CFG80211_ASSOC;
 }
 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
 				  struct ieee80211_mgmt *mgmt,
 				  size_t len,
 				  struct ieee80211_rx_status *rx_status,
 				  struct ieee802_11_elems *elems,
 				  bool beacon)
 {
 	struct ieee80211_local *local = sdata->local;
 	int freq;
 	struct ieee80211_bss *bss;
 	struct ieee80211_channel *channel;
 	if (elems->ds_params && elems->ds_params_len == 1)
 		freq = ieee80211_channel_to_frequency(elems->ds_params[0]);
 	else
 		freq = rx_status->freq;
 	channel = ieee80211_get_channel(local->hw.wiphy, freq);
 	if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
 		return;
 	bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
 					channel, beacon);
 	if (bss)
 		ieee80211_rx_bss_put(local, bss);
 	if (!sdata->u.mgd.associated)
 		return;
 	if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
 	    (memcmp(mgmt->bssid, sdata->u.mgd.associated->cbss.bssid,
 							ETH_ALEN) == 0)) {
 		struct ieee80211_channel_sw_ie *sw_elem =
 			(struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
 		ieee80211_sta_process_chanswitch(sdata, sw_elem, bss);
 	}
 }
 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
 					 struct ieee80211_mgd_work *wk,
 					 struct ieee80211_mgmt *mgmt, size_t len,
 					 struct ieee80211_rx_status *rx_status)
 {
 	struct ieee80211_if_managed *ifmgd;
 	size_t baselen;
 	struct ieee802_11_elems elems;
 	ifmgd = &sdata->u.mgd;
 	ASSERT_MGD_MTX(ifmgd);
 	if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
 		return; /* ignore ProbeResp to foreign address */
 	baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
 	if (baselen > len)
 		return;
 	ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
 				&elems);
 	ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
 	/* direct probe may be part of the association flow */
 	if (wk && wk->state == IEEE80211_MGD_STATE_PROBE) {
 		printk(KERN_DEBUG "%s: direct probe responded\n",
 		       sdata->dev->name);
 		wk->tries = 0;
 		wk->state = IEEE80211_MGD_STATE_AUTH;
 		WARN_ON(ieee80211_authenticate(sdata, wk) != RX_MGMT_NONE);
 	}
 	if (ifmgd->associated &&
 	    memcmp(mgmt->bssid, ifmgd->associated->cbss.bssid, ETH_ALEN) == 0 &&
 	    ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
 			    IEEE80211_STA_CONNECTION_POLL)) {
 		ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
 				  IEEE80211_STA_BEACON_POLL);
 		mutex_lock(&sdata->local->iflist_mtx);
 		ieee80211_recalc_ps(sdata->local, -1);
 		mutex_unlock(&sdata->local->iflist_mtx);
 		/*
 		 * We've received a probe response, but are not sure whether
 		 * we have or will be receiving any beacons or data, so let's
 		 * schedule the timers again, just in case.
 		 */
 		mod_beacon_timer(sdata);
 		mod_timer(&ifmgd->conn_mon_timer,
 			  round_jiffies_up(jiffies +
 					   IEEE80211_CONNECTION_IDLE_TIME));
 	}
 }
 /*
  * This is the canonical list of information elements we care about,
  * the filter code also gives us all changes to the Microsoft OUI
  * (00:50:F2) vendor IE which is used for WMM which we need to track.
  *
  * We implement beacon filtering in software since that means we can
  * avoid processing the frame here and in cfg80211, and userspace
  * will not be able to tell whether the hardware supports it or not.
  *
  * XXX: This list needs to be dynamic -- userspace needs to be able to
  *	add items it requires. It also needs to be able to tell us to
  *	look out for other vendor IEs.
  */
 static const u64 care_about_ies =
 	(1ULL << WLAN_EID_COUNTRY) |
 	(1ULL << WLAN_EID_ERP_INFO) |
 	(1ULL << WLAN_EID_CHANNEL_SWITCH) |
 	(1ULL << WLAN_EID_PWR_CONSTRAINT) |
 	(1ULL << WLAN_EID_HT_CAPABILITY) |
 	(1ULL << WLAN_EID_HT_INFORMATION);
 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_mgmt *mgmt,
 				     size_t len,
 				     struct ieee80211_rx_status *rx_status)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	size_t baselen;
 	struct ieee802_11_elems elems;
 	struct ieee80211_local *local = sdata->local;
 	u32 changed = 0;
 	bool erp_valid, directed_tim = false;
 	u8 erp_value = 0;
 	u32 ncrc;
 	u8 *bssid;
 	ASSERT_MGD_MTX(ifmgd);
 	/* Process beacon from the current BSS */
 	baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
 	if (baselen > len)
 		return;
 	if (rx_status->freq != local->hw.conf.channel->center_freq)
 		return;
 	/*
 	 * We might have received a number of frames, among them a
 	 * disassoc frame and a beacon...
 	 */
 	if (!ifmgd->associated)
 		return;
 	bssid = ifmgd->associated->cbss.bssid;
 	/*
 	 * And in theory even frames from a different AP we were just
 	 * associated to a split-second ago!
 	 */
 	if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0)
 		return;
 	if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 		if (net_ratelimit()) {
 			printk(KERN_DEBUG "%s: cancelling probereq poll due "
 			       "to a received beacon\n", sdata->dev->name);
 		}
 #endif
 		ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
 		mutex_lock(&local->iflist_mtx);
 		ieee80211_recalc_ps(local, -1);
 		mutex_unlock(&local->iflist_mtx);
 	}
 	/*
 	 * Push the beacon loss detection into the future since
 	 * we are processing a beacon from the AP just now.
 	 */
 	mod_beacon_timer(sdata);
 	ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
 	ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
 					  len - baselen, &elems,
 					  care_about_ies, ncrc);
 	if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
 		directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
 						   ifmgd->aid);
 	if (ncrc != ifmgd->beacon_crc) {
 		ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
 				      true);
 		ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
 					 elems.wmm_param_len);
 	}
 	if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
 		if (directed_tim) {
 			if (local->hw.conf.dynamic_ps_timeout > 0) {
 				local->hw.conf.flags &= ~IEEE80211_CONF_PS;
 				ieee80211_hw_config(local,
 						    IEEE80211_CONF_CHANGE_PS);
 				ieee80211_send_nullfunc(local, sdata, 0);
 			} else {
 				local->pspolling = true;
 				/*
 				 * Here is assumed that the driver will be
 				 * able to send ps-poll frame and receive a
 				 * response even though power save mode is
 				 * enabled, but some drivers might require
 				 * to disable power save here. This needs
 				 * to be investigated.
 				 */
 				ieee80211_send_pspoll(local, sdata);
 			}
 		}
 	}
 	if (ncrc == ifmgd->beacon_crc)
 		return;
 	ifmgd->beacon_crc = ncrc;
 	if (elems.erp_info && elems.erp_info_len >= 1) {
 		erp_valid = true;
 		erp_value = elems.erp_info[0];
 	} else {
 		erp_valid = false;
 	}
 	changed |= ieee80211_handle_bss_capability(sdata,
 			le16_to_cpu(mgmt->u.beacon.capab_info),
 			erp_valid, erp_value);
 	if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
 	    !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {
 		struct sta_info *sta;
 		struct ieee80211_supported_band *sband;
 		u16 ap_ht_cap_flags;
 		rcu_read_lock();
 		sta = sta_info_get(local, bssid);
 		if (WARN_ON(!sta)) {
 			rcu_read_unlock();
 			return;
 		}
 		sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 		ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
 				elems.ht_cap_elem, &sta->sta.ht_cap);
 		ap_ht_cap_flags = sta->sta.ht_cap.cap;
 		rcu_read_unlock();
 		changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
 					       bssid, ap_ht_cap_flags);
 	}
 	/* Note: country IE parsing is done for us by cfg80211 */
 	if (elems.country_elem) {
 		/* TODO: IBSS also needs this */
 		if (elems.pwr_constr_elem)
 			ieee80211_handle_pwr_constr(sdata,
 				le16_to_cpu(mgmt->u.probe_resp.capab_info),
 				elems.pwr_constr_elem,
 				elems.pwr_constr_elem_len);
 	}
 	ieee80211_bss_info_change_notify(sdata, changed);
 }
 ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
 					  struct sk_buff *skb)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_mgmt *mgmt;
 	u16 fc;
 	if (skb->len < 24)
 		return RX_DROP_MONITOR;
 	mgmt = (struct ieee80211_mgmt *) skb->data;
 	fc = le16_to_cpu(mgmt->frame_control);
 	switch (fc & IEEE80211_FCTL_STYPE) {
 	case IEEE80211_STYPE_PROBE_REQ:
 	case IEEE80211_STYPE_PROBE_RESP:
 	case IEEE80211_STYPE_BEACON:
 	case IEEE80211_STYPE_AUTH:
 	case IEEE80211_STYPE_ASSOC_RESP:
 	case IEEE80211_STYPE_REASSOC_RESP:
 	case IEEE80211_STYPE_DEAUTH:
 	case IEEE80211_STYPE_DISASSOC:
 	case IEEE80211_STYPE_ACTION:
 		skb_queue_tail(&sdata->u.mgd.skb_queue, skb);
 		ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);
 		return RX_QUEUED;
 	}
 	return RX_DROP_MONITOR;
 }
 static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
 					 struct sk_buff *skb)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_rx_status *rx_status;
 	struct ieee80211_mgmt *mgmt;
 	struct ieee80211_mgd_work *wk;
 	enum rx_mgmt_action rma = RX_MGMT_NONE;
 	u16 fc;
 	rx_status = (struct ieee80211_rx_status *) skb->cb;
 	mgmt = (struct ieee80211_mgmt *) skb->data;
 	fc = le16_to_cpu(mgmt->frame_control);
 	mutex_lock(&ifmgd->mtx);
 	if (ifmgd->associated &&
 	    memcmp(ifmgd->associated->cbss.bssid, mgmt->bssid,
 							ETH_ALEN) == 0) {
 		switch (fc & IEEE80211_FCTL_STYPE) {
 		case IEEE80211_STYPE_BEACON:
 			ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
 						 rx_status);
 			break;
 		case IEEE80211_STYPE_PROBE_RESP:
 			ieee80211_rx_mgmt_probe_resp(sdata, NULL, mgmt,
 						     skb->len, rx_status);
 			break;
 		case IEEE80211_STYPE_DEAUTH:
 			rma = ieee80211_rx_mgmt_deauth(sdata, NULL,
 						       mgmt, skb->len);
 			break;
 		case IEEE80211_STYPE_DISASSOC:
 			rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
 			break;
 		case IEEE80211_STYPE_ACTION:
 			/* XXX: differentiate, can only happen for CSA now! */
 			ieee80211_sta_process_chanswitch(sdata,
 					&mgmt->u.action.u.chan_switch.sw_elem,
 					ifmgd->associated);
 			break;
 		}
 		mutex_unlock(&ifmgd->mtx);
 		switch (rma) {
 		case RX_MGMT_NONE:
 			/* no action */
 			break;
 		case RX_MGMT_CFG80211_DEAUTH:
 			cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len,
 					     NULL);
 			break;
 		case RX_MGMT_CFG80211_DISASSOC:
 			cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len,
 					       NULL);
 			break;
 		default:
 			WARN(1, "unexpected: %d", rma);
 		}
 		goto out;
 	}
 	list_for_each_entry(wk, &ifmgd->work_list, list) {
 		if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
 			continue;
 		switch (fc & IEEE80211_FCTL_STYPE) {
 		case IEEE80211_STYPE_PROBE_RESP:
 			ieee80211_rx_mgmt_probe_resp(sdata, wk, mgmt, skb->len,
 						     rx_status);
 			break;
 		case IEEE80211_STYPE_AUTH:
 			rma = ieee80211_rx_mgmt_auth(sdata, wk, mgmt, skb->len);
 			break;
 		case IEEE80211_STYPE_ASSOC_RESP:
 			rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
 							   skb->len, false);
 			break;
 		case IEEE80211_STYPE_REASSOC_RESP:
 			rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
 							   skb->len, true);
 			break;
 		case IEEE80211_STYPE_DEAUTH:
 			rma = ieee80211_rx_mgmt_deauth(sdata, wk, mgmt,
 						       skb->len);
 			break;
 		}
 		/*
 		 * We've processed this frame for that work, so it can't
 		 * belong to another work struct.
 		 * NB: this is also required for correctness because the
 		 * called functions can free 'wk', and for 'rma'!
 		 */
 		break;
 	}
 	mutex_unlock(&ifmgd->mtx);
 	switch (rma) {
 	case RX_MGMT_NONE:
 		/* no action */
 		break;
 	case RX_MGMT_CFG80211_AUTH:
 		cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, skb->len);
 		break;
 	case RX_MGMT_CFG80211_ASSOC:
 		cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, skb->len);
 		break;
 	case RX_MGMT_CFG80211_DEAUTH:
 		cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, NULL);
 		break;
 	default:
 		WARN(1, "unexpected: %d", rma);
 	}
  out:
 	kfree_skb(skb);
 }
 static void ieee80211_sta_timer(unsigned long data)
 {
 	struct ieee80211_sub_if_data *sdata =
 		(struct ieee80211_sub_if_data *) data;
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	if (local->quiescing) {
 		set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
 		return;
 	}
 	ieee80211_queue_work(&local->hw, &ifmgd->work);
 }
 static void ieee80211_sta_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data, u.mgd.work);
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_if_managed *ifmgd;
 	struct sk_buff *skb;
 	struct ieee80211_mgd_work *wk, *tmp;
 	LIST_HEAD(free_work);
 	enum rx_mgmt_action rma;
 	bool anybusy = false;
 	if (!netif_running(sdata->dev))
 		return;
 	if (local->scanning)
 		return;
 	if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
 		return;
 	/*
 	 * ieee80211_queue_work() should have picked up most cases,
 	 * here we'll pick the the rest.
 	 */
 	if (WARN(local->suspended, "STA MLME work scheduled while "
 		 "going to suspend\n"))
 		return;
 	ifmgd = &sdata->u.mgd;
 	/* first process frames to avoid timing out while a frame is pending */
 	while ((skb = skb_dequeue(&ifmgd->skb_queue)))
 		ieee80211_sta_rx_queued_mgmt(sdata, skb);
 	/* then process the rest of the work */
 	mutex_lock(&ifmgd->mtx);
 	if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
 			    IEEE80211_STA_CONNECTION_POLL) &&
 	    ifmgd->associated) {
 		u8 bssid[ETH_ALEN];
 		memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
 		if (time_is_after_jiffies(ifmgd->probe_timeout))
 			run_again(ifmgd, ifmgd->probe_timeout);
 		else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 			printk(KERN_DEBUG "No probe response from AP %pM"
 				" after %dms, try %d\n", bssid,
 				(1000 * IEEE80211_PROBE_WAIT)/HZ,
 				ifmgd->probe_send_count);
 #endif
 			ieee80211_mgd_probe_ap_send(sdata);
 		} else {
 			/*
 			 * We actually lost the connection ... or did we?
 			 * Let's make sure!
 			 */
 			ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
 					  IEEE80211_STA_BEACON_POLL);
 			printk(KERN_DEBUG "No probe response from AP %pM"
 				" after %dms, disconnecting.\n",
 				bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);
 			ieee80211_set_disassoc(sdata, true);
 			mutex_unlock(&ifmgd->mtx);
 			/*
 			 * must be outside lock due to cfg80211,
 			 * but that's not a problem.
 			 */
 			ieee80211_send_deauth_disassoc(sdata, bssid,
 					IEEE80211_STYPE_DEAUTH,
 					WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
 					NULL);
 			mutex_lock(&ifmgd->mtx);
 		}
 	}
 	ieee80211_recalc_idle(local);
 	list_for_each_entry_safe(wk, tmp, &ifmgd->work_list, list) {
 		if (time_is_after_jiffies(wk->timeout)) {
 			/*
 			 * This work item isn't supposed to be worked on
 			 * right now, but take care to adjust the timer
 			 * properly.
 			 */
 			run_again(ifmgd, wk->timeout);
 			continue;
 		}
 		switch (wk->state) {
 		default:
 			WARN_ON(1);
 			/* fall through */
 		case IEEE80211_MGD_STATE_IDLE:
 			/* nothing */
 			rma = RX_MGMT_NONE;
 			break;
 		case IEEE80211_MGD_STATE_PROBE:
 			rma = ieee80211_direct_probe(sdata, wk);
 			break;
 		case IEEE80211_MGD_STATE_AUTH:
 			rma = ieee80211_authenticate(sdata, wk);
 			break;
 		case IEEE80211_MGD_STATE_ASSOC:
 			rma = ieee80211_associate(sdata, wk);
 			break;
 		}
 		switch (rma) {
 		case RX_MGMT_NONE:
 			/* no action required */
 			break;
 		case RX_MGMT_CFG80211_AUTH_TO:
 		case RX_MGMT_CFG80211_ASSOC_TO:
 			list_del(&wk->list);
 			list_add(&wk->list, &free_work);
 			wk->tries = rma; /* small abuse but only local */
 			break;
 		default:
 			WARN(1, "unexpected: %d", rma);
 		}
 	}
 	list_for_each_entry(wk, &ifmgd->work_list, list) {
 		if (wk->state != IEEE80211_MGD_STATE_IDLE) {
 			anybusy = true;
 			break;
 		}
 	}
 	if (!anybusy &&
 	    test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request))
 		ieee80211_queue_delayed_work(&local->hw,
 					     &local->scan_work,
 					     round_jiffies_relative(0));
 	mutex_unlock(&ifmgd->mtx);
 	list_for_each_entry_safe(wk, tmp, &free_work, list) {
 		switch (wk->tries) {
 		case RX_MGMT_CFG80211_AUTH_TO:
 			cfg80211_send_auth_timeout(sdata->dev,
 						   wk->bss->cbss.bssid);
 			break;
 		case RX_MGMT_CFG80211_ASSOC_TO:
 			cfg80211_send_assoc_timeout(sdata->dev,
 						    wk->bss->cbss.bssid);
 			break;
 		default:
 			WARN(1, "unexpected: %d", wk->tries);
 		}
 		list_del(&wk->list);
 		kfree(wk);
 	}
 	ieee80211_recalc_idle(local);
 }
 static void ieee80211_sta_bcn_mon_timer(unsigned long data)
 {
 	struct ieee80211_sub_if_data *sdata =
 		(struct ieee80211_sub_if_data *) data;
 	struct ieee80211_local *local = sdata->local;
 	if (local->quiescing)
 		return;
 	ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);
 }
 static void ieee80211_sta_conn_mon_timer(unsigned long data)
 {
 	struct ieee80211_sub_if_data *sdata =
 		(struct ieee80211_sub_if_data *) data;
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_local *local = sdata->local;
 	if (local->quiescing)
 		return;
 	ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
 }
 static void ieee80211_sta_monitor_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data,
 			     u.mgd.monitor_work);
 	ieee80211_mgd_probe_ap(sdata, false);
 }
 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
 {
 	if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 		sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |
 					IEEE80211_STA_CONNECTION_POLL);
 		/* let's probe the connection once */
 		ieee80211_queue_work(&sdata->local->hw,
 			   &sdata->u.mgd.monitor_work);
 		/* and do all the other regular work too */
 		ieee80211_queue_work(&sdata->local->hw,
 			   &sdata->u.mgd.work);
 	}
 }
 #ifdef CONFIG_PM
 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	/*
 	 * we need to use atomic bitops for the running bits
 	 * only because both timers might fire at the same
 	 * time -- the code here is properly synchronised.
 	 */
 	cancel_work_sync(&ifmgd->work);
 	cancel_work_sync(&ifmgd->beacon_loss_work);
 	if (del_timer_sync(&ifmgd->timer))
 		set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
 	cancel_work_sync(&ifmgd->chswitch_work);
 	if (del_timer_sync(&ifmgd->chswitch_timer))
 		set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
 	cancel_work_sync(&ifmgd->monitor_work);
 	/* these will just be re-established on connection */
 	del_timer_sync(&ifmgd->conn_mon_timer);
 	del_timer_sync(&ifmgd->bcn_mon_timer);
 }
 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
 		add_timer(&ifmgd->timer);
 	if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
 		add_timer(&ifmgd->chswitch_timer);
 }
 #endif
 /* interface setup */
 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_if_managed *ifmgd;
 	ifmgd = &sdata->u.mgd;
 	INIT_WORK(&ifmgd->work, ieee80211_sta_work);
 	INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
 	INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
 	INIT_WORK(&ifmgd->beacon_loss_work, ieee80211_beacon_loss_work);
 	setup_timer(&ifmgd->timer, ieee80211_sta_timer,
 		    (unsigned long) sdata);
 	setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
 		    (unsigned long) sdata);
 	setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
 		    (unsigned long) sdata);
 	setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
 		    (unsigned long) sdata);
 	skb_queue_head_init(&ifmgd->skb_queue);
 	INIT_LIST_HEAD(&ifmgd->work_list);
 	ifmgd->capab = WLAN_CAPABILITY_ESS;
 	ifmgd->flags = 0;
 	if (sdata->local->hw.queues >= 4)
 		ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;
 	mutex_init(&ifmgd->mtx);
 }
 /* scan finished notification */
 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
 {
 	struct ieee80211_sub_if_data *sdata = local->scan_sdata;
 	/* Restart STA timers */
 	rcu_read_lock();
 	list_for_each_entry_rcu(sdata, &local->interfaces, list)
 		ieee80211_restart_sta_timer(sdata);
 	rcu_read_unlock();
 }
 int ieee80211_max_network_latency(struct notifier_block *nb,
 				  unsigned long data, void *dummy)
 {
 	s32 latency_usec = (s32) data;
 	struct ieee80211_local *local =
 		container_of(nb, struct ieee80211_local,
 			     network_latency_notifier);
 	mutex_lock(&local->iflist_mtx);
 	ieee80211_recalc_ps(local, latency_usec);
 	mutex_unlock(&local->iflist_mtx);
 	return 0;
 }
 /* config hooks */
 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
 		       struct cfg80211_auth_request *req)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	const u8 *ssid;
 	struct ieee80211_mgd_work *wk;
 	u16 auth_alg;
 	switch (req->auth_type) {
 	case NL80211_AUTHTYPE_OPEN_SYSTEM:
 		auth_alg = WLAN_AUTH_OPEN;
 		break;
 	case NL80211_AUTHTYPE_SHARED_KEY:
 		auth_alg = WLAN_AUTH_SHARED_KEY;
 		break;
 	case NL80211_AUTHTYPE_FT:
 		auth_alg = WLAN_AUTH_FT;
 		break;
 	case NL80211_AUTHTYPE_NETWORK_EAP:
 		auth_alg = WLAN_AUTH_LEAP;
 		break;
 	default:
 		return -EOPNOTSUPP;
 	}
 	wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);
 	if (!wk)
 		return -ENOMEM;
 	wk->bss = (void *)req->bss;
 	if (req->ie && req->ie_len) {
 		memcpy(wk->ie, req->ie, req->ie_len);
 		wk->ie_len = req->ie_len;
 	}
 	if (req->key && req->key_len) {
 		wk->key_len = req->key_len;
 		wk->key_idx = req->key_idx;
 		memcpy(wk->key, req->key, req->key_len);
 	}
 	ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
 	memcpy(wk->ssid, ssid + 2, ssid[1]);
 	wk->ssid_len = ssid[1];
 	wk->state = IEEE80211_MGD_STATE_PROBE;
 	wk->auth_alg = auth_alg;
 	wk->timeout = jiffies; /* run right away */
 	/*
 	 * XXX: if still associated need to tell AP that we're going
 	 *	to sleep and then change channel etc.
 	 */
 	sdata->local->oper_channel = req->bss->channel;
 	ieee80211_hw_config(sdata->local, 0);
 	mutex_lock(&ifmgd->mtx);
 	list_add(&wk->list, &sdata->u.mgd.work_list);
 	mutex_unlock(&ifmgd->mtx);
 	ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
 	return 0;
 }
 int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
 			struct cfg80211_assoc_request *req)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_mgd_work *wk, *found = NULL;
 	int i, err;
 	mutex_lock(&ifmgd->mtx);
 	list_for_each_entry(wk, &ifmgd->work_list, list) {
 		if (&wk->bss->cbss == req->bss &&
 		    wk->state == IEEE80211_MGD_STATE_IDLE) {
 			found = wk;
 			break;
 		}
 	}
 	if (!found) {
 		err = -ENOLINK;
 		goto out;
 	}
 	list_del(&found->list);
 	wk = krealloc(found, sizeof(*wk) + req->ie_len, GFP_KERNEL);
 	if (!wk) {
 		list_add(&found->list, &ifmgd->work_list);
 		err = -ENOMEM;
 		goto out;
 	}
 	list_add(&wk->list, &ifmgd->work_list);
 	ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
 	for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)
 		if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
 		    req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
 		    req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)
 			ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
 	sdata->local->oper_channel = req->bss->channel;
 	ieee80211_hw_config(sdata->local, 0);
 	if (req->ie && req->ie_len) {
 		memcpy(wk->ie, req->ie, req->ie_len);
 		wk->ie_len = req->ie_len;
 	} else
 		wk->ie_len = 0;
 	if (req->prev_bssid)
 		memcpy(wk->prev_bssid, req->prev_bssid, ETH_ALEN);
 	wk->state = IEEE80211_MGD_STATE_ASSOC;
 	wk->tries = 0;
 	wk->timeout = jiffies; /* run right away */
 	if (req->use_mfp) {
 		ifmgd->mfp = IEEE80211_MFP_REQUIRED;
 		ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
 	} else {
 		ifmgd->mfp = IEEE80211_MFP_DISABLED;
 		ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
 	}
 	if (req->crypto.control_port)
 		ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
 	else
 		ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
 	ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
 	err = 0;
  out:
 	mutex_unlock(&ifmgd->mtx);
 	return err;
 }
 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
 			 struct cfg80211_deauth_request *req,
 			 void *cookie)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct ieee80211_mgd_work *wk;
 	const u8 *bssid = NULL;
 	mutex_lock(&ifmgd->mtx);
 	if (ifmgd->associated && &ifmgd->associated->cbss == req->bss) {
 		bssid = req->bss->bssid;
 		ieee80211_set_disassoc(sdata, true);
 	} else list_for_each_entry(wk, &ifmgd->work_list, list) {
 		if (&wk->bss->cbss == req->bss) {
 			bssid = req->bss->bssid;
 			list_del(&wk->list);
 			kfree(wk);
 			break;
 		}
 	}
 	/*
 	 * cfg80211 should catch this ... but it's racy since
 	 * we can receive a deauth frame, process it, hand it
 	 * to cfg80211 while that's in a locked section already
 	 * trying to tell us that the user wants to disconnect.
 	 */
 	if (!bssid) {
 		mutex_unlock(&ifmgd->mtx);
 		return -ENOLINK;
 	}
 	mutex_unlock(&ifmgd->mtx);
 	printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n",
 	       sdata->dev->name, bssid, req->reason_code);
 	ieee80211_send_deauth_disassoc(sdata, bssid,
 			IEEE80211_STYPE_DEAUTH, req->reason_code,
 			cookie);
 	return 0;
 }
 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
 			   struct cfg80211_disassoc_request *req,
 			   void *cookie)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	mutex_lock(&ifmgd->mtx);
 	/*
 	 * cfg80211 should catch this ... but it's racy since
 	 * we can receive a disassoc frame, process it, hand it
 	 * to cfg80211 while that's in a locked section already
 	 * trying to tell us that the user wants to disconnect.
 	 */
 	if (&ifmgd->associated->cbss != req->bss) {
 		mutex_unlock(&ifmgd->mtx);
 		return -ENOLINK;
 	}
 	printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
 	       sdata->dev->name, req->bss->bssid, req->reason_code);
 	ieee80211_set_disassoc(sdata, false);
 	mutex_unlock(&ifmgd->mtx);
 	ieee80211_send_deauth_disassoc(sdata, req->bss->bssid,
 			IEEE80211_STYPE_DISASSOC, req->reason_code,
 			cookie);
 	return 0;
 }