Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* Interface handling (except master interface)

2

* Interface handling (except master interface)

3

*

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

#include <linux/slab.h>

13

#include <linux/slab.h>

14

#include <linux/kernel.h>

14

#include <linux/kernel.h>

15

#include <linux/if_arp.h>

15

#include <linux/if_arp.h>

16

#include <linux/netdevice.h>

16

#include <linux/netdevice.h>

17

#include <linux/rtnetlink.h>

17

#include <linux/rtnetlink.h>

18

#include <net/mac80211.h>

18

#include <net/mac80211.h>

19

#include <net/ieee80211_radiotap.h>

19

#include <net/ieee80211_radiotap.h>

20

#include "ieee80211_i.h"

20

#include "ieee80211_i.h"

21

#include "sta_info.h"

21

#include "sta_info.h"

22

#include "debugfs_netdev.h"

22

#include "debugfs_netdev.h"

23

#include "mesh.h"

23

#include "mesh.h"

24

#include "led.h"

24

#include "led.h"

25

#include "driver-ops.h"

25

#include "driver-ops.h"

26

#include "wme.h"

26

#include "wme.h"

27

#include "rate.h"

27

#include "rate.h"

28

29

/**

29

/**

30

* DOC: Interface list locking

30

* DOC: Interface list locking

31

*

31

*

32

* The interface list in each struct ieee80211_local is protected

32

* The interface list in each struct ieee80211_local is protected

33

* three-fold:

33

* three-fold:

34

*

34

*

35

* (1) modifications may only be done under the RTNL

35

* (1) modifications may only be done under the RTNL

36

* (2) modifications and readers are protected against each other by

36

* (2) modifications and readers are protected against each other by

37

* the iflist_mtx.

37

* the iflist_mtx.

38

* (3) modifications are done in an RCU manner so atomic readers

38

* (3) modifications are done in an RCU manner so atomic readers

39

* can traverse the list in RCU-safe blocks.

39

* can traverse the list in RCU-safe blocks.

40

*

40

*

41

* As a consequence, reads (traversals) of the list can be protected

41

* As a consequence, reads (traversals) of the list can be protected

42

* by either the RTNL, the iflist_mtx or RCU.

42

* by either the RTNL, the iflist_mtx or RCU.

43

*/

43

*/

44

45

bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)

45

bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)

46

{

46

{

47

struct ieee80211_chanctx_conf *chanctx_conf;

47

struct ieee80211_chanctx_conf *chanctx_conf;

48

int power;

48

int power;

49

50

rcu_read_lock();

50

rcu_read_lock();

51

chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);

51

chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);

52

if (!chanctx_conf) {

52

if (!chanctx_conf) {

53

rcu_read_unlock();

53

rcu_read_unlock();

54

return false;

54

return false;

55

}

55

}

56

57

power = chanctx_conf->def.chan->max_power;

57

power = chanctx_conf->def.chan->max_power;

58

rcu_read_unlock();

58

rcu_read_unlock();

59

60

if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)

60

if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)

61

power = min(power, sdata->user_power_level);

61

power = min(power, sdata->user_power_level);

62

63

if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)

63

if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)

64

power = min(power, sdata->ap_power_level);

64

power = min(power, sdata->ap_power_level);

65

66

if (power != sdata->vif.bss_conf.txpower) {

66

if (power != sdata->vif.bss_conf.txpower) {

67

sdata->vif.bss_conf.txpower = power;

67

sdata->vif.bss_conf.txpower = power;

68

ieee80211_hw_config(sdata->local, 0);

68

ieee80211_hw_config(sdata->local, 0);

69

return true;

69

return true;

70

}

70

}

71

72

return false;

72

return false;

73

}

73

}

74

75

void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)

75

void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)

76

{

76

{

77

if (__ieee80211_recalc_txpower(sdata))

77

if (__ieee80211_recalc_txpower(sdata))

78

ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);

78

ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);

79

}

79

}

80

81

static u32 ieee80211_idle_off(struct ieee80211_local *local)

81

static u32 ieee80211_idle_off(struct ieee80211_local *local)

82

{

82

{

83

if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))

83

if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))

84

return 0;

84

return 0;

85

86

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

86

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

87

return IEEE80211_CONF_CHANGE_IDLE;

87

return IEEE80211_CONF_CHANGE_IDLE;

88

}

88

}

89

90

static u32 ieee80211_idle_on(struct ieee80211_local *local)

90

static u32 ieee80211_idle_on(struct ieee80211_local *local)

91

{

91

{

92

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

92

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

93

return 0;

93

return 0;

94

95

drv_flush(local, false);

95

drv_flush(local, false);

96

97

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

97

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

98

return IEEE80211_CONF_CHANGE_IDLE;

98

return IEEE80211_CONF_CHANGE_IDLE;

99

}

99

}

100

101

void ieee80211_recalc_idle(struct ieee80211_local *local)

101

void ieee80211_recalc_idle(struct ieee80211_local *local)

102

{

102

{

103

bool working = false, scanning, active;

103

bool working = false, scanning, active;

104

unsigned int led_trig_start = 0, led_trig_stop = 0;

104

unsigned int led_trig_start = 0, led_trig_stop = 0;

105

struct ieee80211_roc_work *roc;

105

struct ieee80211_roc_work *roc;

106

u32 change;

106

u32 change;

107

108

lockdep_assert_held(&local->mtx);

108

lockdep_assert_held(&local->mtx);

109

110

active = !list_empty(&local->chanctx_list) || local->monitors;

110

active = !list_empty(&local->chanctx_list) || local->monitors;

111

112

if (!local->ops->remain_on_channel) {

112

if (!local->ops->remain_on_channel) {

113

list_for_each_entry(roc, &local->roc_list, list) {

113

list_for_each_entry(roc, &local->roc_list, list) {

114

working = true;

114

working = true;

115

break;

115

break;

116

}

116

}

117

}

117

}

118

119

scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||

119

scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||

120

test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);

120

test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);

121

122

if (working || scanning)

122

if (working || scanning)

123

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;

123

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;

124

else

124

else

125

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;

125

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;

126

127

if (active)

127

if (active)

128

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

128

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

129

else

129

else

130

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

130

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

131

132

ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);

132

ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);

133

134

if (working || scanning || active)

134

if (working || scanning || active)

135

change = ieee80211_idle_off(local);

135

change = ieee80211_idle_off(local);

136

else

136

else

137

change = ieee80211_idle_on(local);

137

change = ieee80211_idle_on(local);

138

if (change)

138

if (change)

139

ieee80211_hw_config(local, change);

139

ieee80211_hw_config(local, change);

140

}

140

}

141

142

static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)

142

static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)

143

{

143

{

144

if (new_mtu < 256 || new_mtu > IEEE80211_MAX_DATA_LEN)

144

if (new_mtu < 256 || new_mtu > IEEE80211_MAX_DATA_LEN)

145

return -EINVAL;

145

return -EINVAL;

146

147

dev->mtu = new_mtu;

147

dev->mtu = new_mtu;

148

return 0;

148

return 0;

149

}

149

}

150

151

static int ieee80211_verify_mac(struct ieee80211_local *local, u8 *addr)

151

static int ieee80211_verify_mac(struct ieee80211_local *local, u8 *addr)

152

{

152

{

153

struct ieee80211_sub_if_data *sdata;

153

struct ieee80211_sub_if_data *sdata;

154

u64 new, mask, tmp;

154

u64 new, mask, tmp;

155

u8 *m;

155

u8 *m;

156

int ret = 0;

156

int ret = 0;

157

158

if (is_zero_ether_addr(local->hw.wiphy->addr_mask))

158

if (is_zero_ether_addr(local->hw.wiphy->addr_mask))

159

return 0;

159

return 0;

160

161

m = addr;

161

m = addr;

162

new = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

162

new = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

163

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

163

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

164

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

164

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

165

166

m = local->hw.wiphy->addr_mask;

166

m = local->hw.wiphy->addr_mask;

167

mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

167

mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

168

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

168

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

169

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

169

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

170

171

172

mutex_lock(&local->iflist_mtx);

172

mutex_lock(&local->iflist_mtx);

173

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

173

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

174

if (sdata->vif.type == NL80211_IFTYPE_MONITOR)

174

if (sdata->vif.type == NL80211_IFTYPE_MONITOR)

175

continue;

175

continue;

176

177

m = sdata->vif.addr;

177

m = sdata->vif.addr;

178

tmp = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

178

tmp = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

179

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

179

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

180

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

180

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

181

182

if ((new & ~mask) != (tmp & ~mask)) {

182

if ((new & ~mask) != (tmp & ~mask)) {

183

ret = -EINVAL;

183

ret = -EINVAL;

184

break;

184

break;

185

}

185

}

186

}

186

}

187

mutex_unlock(&local->iflist_mtx);

187

mutex_unlock(&local->iflist_mtx);

188

189

return ret;

189

return ret;

190

}

190

}

191

192

static int ieee80211_change_mac(struct net_device *dev, void *addr)

192

static int ieee80211_change_mac(struct net_device *dev, void *addr)

193

{

193

{

194

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

194

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

195

struct sockaddr *sa = addr;

195

struct sockaddr *sa = addr;

196

int ret;

196

int ret;

197

198

if (ieee80211_sdata_running(sdata))

198

if (ieee80211_sdata_running(sdata))

199

return -EBUSY;

199

return -EBUSY;

200

201

ret = ieee80211_verify_mac(sdata->local, sa->sa_data);

201

ret = ieee80211_verify_mac(sdata->local, sa->sa_data);

202

if (ret)

202

if (ret)

203

return ret;

203

return ret;

204

205

ret = eth_mac_addr(dev, sa);

205

ret = eth_mac_addr(dev, sa);

206

207

if (ret == 0)

207

if (ret == 0)

208

memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);

208

memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);

209

210

return ret;

210

return ret;

211

}

211

}

212

213

static inline int identical_mac_addr_allowed(int type1, int type2)

213

static inline int identical_mac_addr_allowed(int type1, int type2)

214

{

214

{

215

return type1 == NL80211_IFTYPE_MONITOR ||

215

return type1 == NL80211_IFTYPE_MONITOR ||

216

type2 == NL80211_IFTYPE_MONITOR ||

216

type2 == NL80211_IFTYPE_MONITOR ||

217

type1 == NL80211_IFTYPE_P2P_DEVICE ||

217

type1 == NL80211_IFTYPE_P2P_DEVICE ||

218

type2 == NL80211_IFTYPE_P2P_DEVICE ||

218

type2 == NL80211_IFTYPE_P2P_DEVICE ||

219

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||

219

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||

220

(type1 == NL80211_IFTYPE_WDS &&

220

(type1 == NL80211_IFTYPE_WDS &&

221

(type2 == NL80211_IFTYPE_WDS ||

221

(type2 == NL80211_IFTYPE_WDS ||

222

type2 == NL80211_IFTYPE_AP)) ||

222

type2 == NL80211_IFTYPE_AP)) ||

223

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||

223

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||

224

(type1 == NL80211_IFTYPE_AP_VLAN &&

224

(type1 == NL80211_IFTYPE_AP_VLAN &&

225

(type2 == NL80211_IFTYPE_AP ||

225

(type2 == NL80211_IFTYPE_AP ||

226

type2 == NL80211_IFTYPE_AP_VLAN));

226

type2 == NL80211_IFTYPE_AP_VLAN));

227

}

227

}

228

229

static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,

229

static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,

230

enum nl80211_iftype iftype)

230

enum nl80211_iftype iftype)

231

{

231

{

232

struct ieee80211_local *local = sdata->local;

232

struct ieee80211_local *local = sdata->local;

233

struct ieee80211_sub_if_data *nsdata;

233

struct ieee80211_sub_if_data *nsdata;

234

235

ASSERT_RTNL();

235

ASSERT_RTNL();

236

237

/* we hold the RTNL here so can safely walk the list */

237

/* we hold the RTNL here so can safely walk the list */

238

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

238

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

239

if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {

239

if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {

240

/*

240

/*

241

* Allow only a single IBSS interface to be up at any

241

* Allow only a single IBSS interface to be up at any

242

* time. This is restricted because beacon distribution

242

* time. This is restricted because beacon distribution

243

* cannot work properly if both are in the same IBSS.

243

* cannot work properly if both are in the same IBSS.

244

*

244

*

245

* To remove this restriction we'd have to disallow them

245

* To remove this restriction we'd have to disallow them

246

* from setting the same SSID on different IBSS interfaces

246

* from setting the same SSID on different IBSS interfaces

247

* belonging to the same hardware. Then, however, we're

247

* belonging to the same hardware. Then, however, we're

248

* faced with having to adopt two different TSF timers...

248

* faced with having to adopt two different TSF timers...

249

*/

249

*/

250

if (iftype == NL80211_IFTYPE_ADHOC &&

250

if (iftype == NL80211_IFTYPE_ADHOC &&

251

nsdata->vif.type == NL80211_IFTYPE_ADHOC)

251

nsdata->vif.type == NL80211_IFTYPE_ADHOC)

252

return -EBUSY;

252

return -EBUSY;

253

254

/*

254

/*

255

* The remaining checks are only performed for interfaces

255

* The remaining checks are only performed for interfaces

256

* with the same MAC address.

256

* with the same MAC address.

257

*/

257

*/

258

if (!ether_addr_equal(sdata->vif.addr,

258

if (!ether_addr_equal(sdata->vif.addr,

259

nsdata->vif.addr))

259

nsdata->vif.addr))

260

continue;

260

continue;

261

262

/*

262

/*

263

* check whether it may have the same address

263

* check whether it may have the same address

264

*/

264

*/

265

if (!identical_mac_addr_allowed(iftype,

265

if (!identical_mac_addr_allowed(iftype,

266

nsdata->vif.type))

266

nsdata->vif.type))

267

return -ENOTUNIQ;

267

return -ENOTUNIQ;

268

269

/*

269

/*

270

* can only add VLANs to enabled APs

270

* can only add VLANs to enabled APs

271

*/

271

*/

272

if (iftype == NL80211_IFTYPE_AP_VLAN &&

272

if (iftype == NL80211_IFTYPE_AP_VLAN &&

273

nsdata->vif.type == NL80211_IFTYPE_AP)

273

nsdata->vif.type == NL80211_IFTYPE_AP)

274

sdata->bss = &nsdata->u.ap;

274

sdata->bss = &nsdata->u.ap;

275

}

275

}

276

}

276

}

277

278

return 0;

278

return 0;

279

}

279

}

280

281

static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata)

281

static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata)

282

{

282

{

283

int n_queues = sdata->local->hw.queues;

283

int n_queues = sdata->local->hw.queues;

284

int i;

284

int i;

285

286

if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {

286

if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {

287

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

287

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

288

if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==

288

if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==

289

IEEE80211_INVAL_HW_QUEUE))

289

IEEE80211_INVAL_HW_QUEUE))

290

return -EINVAL;

290

return -EINVAL;

291

if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=

291

if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=

292

n_queues))

292

n_queues))

293

return -EINVAL;

293

return -EINVAL;

294

}

294

}

295

}

295

}

296

297

if ((sdata->vif.type != NL80211_IFTYPE_AP &&

297

if ((sdata->vif.type != NL80211_IFTYPE_AP &&

298

sdata->vif.type != NL80211_IFTYPE_MESH_POINT) ||

298

sdata->vif.type != NL80211_IFTYPE_MESH_POINT) ||

299

!(sdata->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) {

299

!(sdata->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) {

300

sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;

300

sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;

301

return 0;

301

return 0;

302

}

302

}

303

304

if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))

304

if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))

305

return -EINVAL;

305

return -EINVAL;

306

307

if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))

307

if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))

308

return -EINVAL;

308

return -EINVAL;

309

310

return 0;

310

return 0;

311

}

311

}

312

313

void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,

313

void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,

314

const int offset)

314

const int offset)

315

{

315

{

316

struct ieee80211_local *local = sdata->local;

316

struct ieee80211_local *local = sdata->local;

317

u32 flags = sdata->u.mntr_flags;

317

u32 flags = sdata->u.mntr_flags;

318

319

#define ADJUST(_f, _s) do { \

319

#define ADJUST(_f, _s) do { \

320

if (flags & MONITOR_FLAG_##_f) \

320

if (flags & MONITOR_FLAG_##_f) \

321

local->fif_##_s += offset; \

321

local->fif_##_s += offset; \

322

} while (0)

322

} while (0)

323

324

ADJUST(FCSFAIL, fcsfail);

324

ADJUST(FCSFAIL, fcsfail);

325

ADJUST(PLCPFAIL, plcpfail);

325

ADJUST(PLCPFAIL, plcpfail);

326

ADJUST(CONTROL, control);

326

ADJUST(CONTROL, control);

327

ADJUST(CONTROL, pspoll);

327

ADJUST(CONTROL, pspoll);

328

ADJUST(OTHER_BSS, other_bss);

328

ADJUST(OTHER_BSS, other_bss);

329

330

#undef ADJUST

330

#undef ADJUST

331

}

331

}

332

333

static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)

333

static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)

334

{

334

{

335

struct ieee80211_local *local = sdata->local;

335

struct ieee80211_local *local = sdata->local;

336

int i;

336

int i;

337

338

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

338

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

339

if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)

339

if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)

340

sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;

340

sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;

341

else if (local->hw.queues >= IEEE80211_NUM_ACS)

341

else if (local->hw.queues >= IEEE80211_NUM_ACS)

342

sdata->vif.hw_queue[i] = i;

342

sdata->vif.hw_queue[i] = i;

343

else

343

else

344

sdata->vif.hw_queue[i] = 0;

344

sdata->vif.hw_queue[i] = 0;

345

}

345

}

346

sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;

346

sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;

347

}

347

}

348

349

static int ieee80211_add_virtual_monitor(struct ieee80211_local *local)

349

static int ieee80211_add_virtual_monitor(struct ieee80211_local *local)

350

{

350

{

351

struct ieee80211_sub_if_data *sdata;

351

struct ieee80211_sub_if_data *sdata;

352

int ret = 0;

352

int ret = 0;

353

354

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

354

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

355

return 0;

355

return 0;

356

357

mutex_lock(&local->iflist_mtx);

357

mutex_lock(&local->iflist_mtx);

358

359

if (local->monitor_sdata)

359

if (local->monitor_sdata)

360

goto out_unlock;

360

goto out_unlock;

361

362

sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);

362

sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);

363

if (!sdata) {

363

if (!sdata) {

364

ret = -ENOMEM;

364

ret = -ENOMEM;

365

goto out_unlock;

365

goto out_unlock;

366

}

366

}

367

368

/* set up data */

368

/* set up data */

369

sdata->local = local;

369

sdata->local = local;

370

sdata->vif.type = NL80211_IFTYPE_MONITOR;

370

sdata->vif.type = NL80211_IFTYPE_MONITOR;

371

snprintf(sdata->name, IFNAMSIZ, "%s-monitor",

371

snprintf(sdata->name, IFNAMSIZ, "%s-monitor",

372

wiphy_name(local->hw.wiphy));

372

wiphy_name(local->hw.wiphy));

373

374

ieee80211_set_default_queues(sdata);

374

ieee80211_set_default_queues(sdata);

375

376

ret = drv_add_interface(local, sdata);

376

ret = drv_add_interface(local, sdata);

377

if (WARN_ON(ret)) {

377

if (WARN_ON(ret)) {

378

/* ok .. stupid driver, it asked for this! */

378

/* ok .. stupid driver, it asked for this! */

379

kfree(sdata);

379

kfree(sdata);

380

goto out_unlock;

380

goto out_unlock;

381

}

381

}

382

383

ret = ieee80211_check_queues(sdata);

383

ret = ieee80211_check_queues(sdata);

384

if (ret) {

384

if (ret) {

385

kfree(sdata);

385

kfree(sdata);

386

goto out_unlock;

386

goto out_unlock;

387

}

387

}

388

389

ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,

389

ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,

390

IEEE80211_CHANCTX_EXCLUSIVE);

390

IEEE80211_CHANCTX_EXCLUSIVE);

391

if (ret) {

391

if (ret) {

392

drv_remove_interface(local, sdata);

392

drv_remove_interface(local, sdata);

393

kfree(sdata);

393

kfree(sdata);

394

goto out_unlock;

394

goto out_unlock;

395

}

395

}

396

397

rcu_assign_pointer(local->monitor_sdata, sdata);

397

rcu_assign_pointer(local->monitor_sdata, sdata);

398

out_unlock:

398

out_unlock:

399

mutex_unlock(&local->iflist_mtx);

399

mutex_unlock(&local->iflist_mtx);

400

return ret;

400

return ret;

401

}

401

}

402

403

static void ieee80211_del_virtual_monitor(struct ieee80211_local *local)

403

static void ieee80211_del_virtual_monitor(struct ieee80211_local *local)

404

{

404

{

405

struct ieee80211_sub_if_data *sdata;

405

struct ieee80211_sub_if_data *sdata;

406

407

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

407

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

408

return;

408

return;

409

410

mutex_lock(&local->iflist_mtx);

410

mutex_lock(&local->iflist_mtx);

411

412

sdata = rcu_dereference_protected(local->monitor_sdata,

412

sdata = rcu_dereference_protected(local->monitor_sdata,

413

lockdep_is_held(&local->iflist_mtx));

413

lockdep_is_held(&local->iflist_mtx));

414

if (!sdata)

414

if (!sdata)

415

goto out_unlock;

415

goto out_unlock;

416

417

rcu_assign_pointer(local->monitor_sdata, NULL);

417

rcu_assign_pointer(local->monitor_sdata, NULL);

418

synchronize_net();

418

synchronize_net();

419

420

ieee80211_vif_release_channel(sdata);

420

ieee80211_vif_release_channel(sdata);

421

422

drv_remove_interface(local, sdata);

422

drv_remove_interface(local, sdata);

423

424

kfree(sdata);

424

kfree(sdata);

425

out_unlock:

425

out_unlock:

426

mutex_unlock(&local->iflist_mtx);

426

mutex_unlock(&local->iflist_mtx);

427

}

427

}

428

429

/*

429

/*

430

* NOTE: Be very careful when changing this function, it must NOT return

430

* NOTE: Be very careful when changing this function, it must NOT return

431

* an error on interface type changes that have been pre-checked, so most

431

* an error on interface type changes that have been pre-checked, so most

432

* checks should be in ieee80211_check_concurrent_iface.

432

* checks should be in ieee80211_check_concurrent_iface.

433

*/

433

*/

434

int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)

434

int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)

435

{

435

{

436

struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);

436

struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);

437

struct net_device *dev = wdev->netdev;

437

struct net_device *dev = wdev->netdev;

438

struct ieee80211_local *local = sdata->local;

438

struct ieee80211_local *local = sdata->local;

439

struct sta_info *sta;

439

struct sta_info *sta;

440

u32 changed = 0;

440

u32 changed = 0;

441

int res;

441

int res;

442

u32 hw_reconf_flags = 0;

442

u32 hw_reconf_flags = 0;

443

444

switch (sdata->vif.type) {

444

switch (sdata->vif.type) {

445

case NL80211_IFTYPE_WDS:

445

case NL80211_IFTYPE_WDS:

446

if (!is_valid_ether_addr(sdata->u.wds.remote_addr))

446

if (!is_valid_ether_addr(sdata->u.wds.remote_addr))

447

return -ENOLINK;

447

return -ENOLINK;

448

break;

448

break;

449

case NL80211_IFTYPE_AP_VLAN: {

449

case NL80211_IFTYPE_AP_VLAN: {

450

struct ieee80211_sub_if_data *master;

450

struct ieee80211_sub_if_data *master;

451

452

if (!sdata->bss)

452

if (!sdata->bss)

453

return -ENOLINK;

453

return -ENOLINK;

454

455

list_add(&sdata->u.vlan.list, &sdata->bss->vlans);

455

list_add(&sdata->u.vlan.list, &sdata->bss->vlans);

456

457

master = container_of(sdata->bss,

457

master = container_of(sdata->bss,

458

struct ieee80211_sub_if_data, u.ap);

458

struct ieee80211_sub_if_data, u.ap);

459

sdata->control_port_protocol =

459

sdata->control_port_protocol =

460

master->control_port_protocol;

460

master->control_port_protocol;

461

sdata->control_port_no_encrypt =

461

sdata->control_port_no_encrypt =

462

master->control_port_no_encrypt;

462

master->control_port_no_encrypt;

463

break;

463

break;

464

}

464

}

465

case NL80211_IFTYPE_AP:

465

case NL80211_IFTYPE_AP:

466

sdata->bss = &sdata->u.ap;

466

sdata->bss = &sdata->u.ap;

467

break;

467

break;

468

case NL80211_IFTYPE_MESH_POINT:

468

case NL80211_IFTYPE_MESH_POINT:

469

case NL80211_IFTYPE_STATION:

469

case NL80211_IFTYPE_STATION:

470

case NL80211_IFTYPE_MONITOR:

470

case NL80211_IFTYPE_MONITOR:

471

case NL80211_IFTYPE_ADHOC:

471

case NL80211_IFTYPE_ADHOC:

472

case NL80211_IFTYPE_P2P_DEVICE:

472

case NL80211_IFTYPE_P2P_DEVICE:

473

/* no special treatment */

473

/* no special treatment */

474

break;

474

break;

475

case NL80211_IFTYPE_UNSPECIFIED:

475

case NL80211_IFTYPE_UNSPECIFIED:

476

case NUM_NL80211_IFTYPES:

476

case NUM_NL80211_IFTYPES:

477

case NL80211_IFTYPE_P2P_CLIENT:

477

case NL80211_IFTYPE_P2P_CLIENT:

478

case NL80211_IFTYPE_P2P_GO:

478

case NL80211_IFTYPE_P2P_GO:

479

/* cannot happen */

479

/* cannot happen */

480

WARN_ON(1);

480

WARN_ON(1);

481

break;

481

break;

482

}

482

}

483

484

if (local->open_count == 0) {

484

if (local->open_count == 0) {

485

res = drv_start(local);

485

res = drv_start(local);

486

if (res)

486

if (res)

487

goto err_del_bss;

487

goto err_del_bss;

488

/* we're brought up, everything changes */

488

/* we're brought up, everything changes */

489

hw_reconf_flags = ~0;

489

hw_reconf_flags = ~0;

490

ieee80211_led_radio(local, true);

490

ieee80211_led_radio(local, true);

491

ieee80211_mod_tpt_led_trig(local,

491

ieee80211_mod_tpt_led_trig(local,

492

IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);

492

IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);

493

}

493

}

494

495

/*

495

/*

496

* Copy the hopefully now-present MAC address to

496

* Copy the hopefully now-present MAC address to

497

* this interface, if it has the special null one.

497

* this interface, if it has the special null one.

498

*/

498

*/

499

if (dev && is_zero_ether_addr(dev->dev_addr)) {

499

if (dev && is_zero_ether_addr(dev->dev_addr)) {

500

memcpy(dev->dev_addr,

500

memcpy(dev->dev_addr,

501

local->hw.wiphy->perm_addr,

501

local->hw.wiphy->perm_addr,

502

ETH_ALEN);

502

ETH_ALEN);

503

memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);

503

memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);

504

505

if (!is_valid_ether_addr(dev->dev_addr)) {

505

if (!is_valid_ether_addr(dev->dev_addr)) {

506

res = -EADDRNOTAVAIL;

506

res = -EADDRNOTAVAIL;

507

goto err_stop;

507

goto err_stop;

508

}

508

}

509

}

509

}

510

511

switch (sdata->vif.type) {

511

switch (sdata->vif.type) {

512

case NL80211_IFTYPE_AP_VLAN:

512

case NL80211_IFTYPE_AP_VLAN:

513

/* no need to tell driver, but set carrier and chanctx */

513

/* no need to tell driver, but set carrier and chanctx */

514

if (rtnl_dereference(sdata->bss->beacon)) {

514

if (rtnl_dereference(sdata->bss->beacon)) {

515

ieee80211_vif_vlan_copy_chanctx(sdata);

515

ieee80211_vif_vlan_copy_chanctx(sdata);

516

netif_carrier_on(dev);

516

netif_carrier_on(dev);

517

} else {

517

} else {

518

netif_carrier_off(dev);

518

netif_carrier_off(dev);

519

}

519

}

520

break;

520

break;

521

case NL80211_IFTYPE_MONITOR:

521

case NL80211_IFTYPE_MONITOR:

522

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

522

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

523

local->cooked_mntrs++;

523

local->cooked_mntrs++;

524

break;

524

break;

525

}

525

}

526

527

if (local->monitors == 0 && local->open_count == 0) {

527

if (local->monitors == 0 && local->open_count == 0) {

528

res = ieee80211_add_virtual_monitor(local);

528

res = ieee80211_add_virtual_monitor(local);

529

if (res)

529

if (res)

530

goto err_stop;

530

goto err_stop;

531

}

531

}

532

533

/* must be before the call to ieee80211_configure_filter */

533

/* must be before the call to ieee80211_configure_filter */

534

local->monitors++;

534

local->monitors++;

535

if (local->monitors == 1) {

535

if (local->monitors == 1) {

536

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

536

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

537

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

537

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

538

}

538

}

539

540

ieee80211_adjust_monitor_flags(sdata, 1);

540

ieee80211_adjust_monitor_flags(sdata, 1);

541

ieee80211_configure_filter(local);

541

ieee80211_configure_filter(local);

542

mutex_lock(&local->mtx);

542

mutex_lock(&local->mtx);

543

ieee80211_recalc_idle(local);

543

ieee80211_recalc_idle(local);

544

mutex_unlock(&local->mtx);

544

mutex_unlock(&local->mtx);

545

546

netif_carrier_on(dev);

546

netif_carrier_on(dev);

547

break;

547

break;

548

default:

548

default:

549

if (coming_up) {

549

if (coming_up) {

550

ieee80211_del_virtual_monitor(local);

550

ieee80211_del_virtual_monitor(local);

551

552

res = drv_add_interface(local, sdata);

552

res = drv_add_interface(local, sdata);

553

if (res)

553

if (res)

554

goto err_stop;

554

goto err_stop;

555

res = ieee80211_check_queues(sdata);

555

res = ieee80211_check_queues(sdata);

556

if (res)

556

if (res)

557

goto err_del_interface;

557

goto err_del_interface;

558

}

558

}

559

560

drv_add_interface_debugfs(local, sdata);

560

drv_add_interface_debugfs(local, sdata);

561

562

if (sdata->vif.type == NL80211_IFTYPE_AP) {

562

if (sdata->vif.type == NL80211_IFTYPE_AP) {

563

local->fif_pspoll++;

563

local->fif_pspoll++;

564

local->fif_probe_req++;

564

local->fif_probe_req++;

565

566

ieee80211_configure_filter(local);

566

ieee80211_configure_filter(local);

567

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

567

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

568

local->fif_probe_req++;

568

local->fif_probe_req++;

569

}

569

}

570

571

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

571

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

572

changed |= ieee80211_reset_erp_info(sdata);

572

changed |= ieee80211_reset_erp_info(sdata);

573

ieee80211_bss_info_change_notify(sdata, changed);

573

ieee80211_bss_info_change_notify(sdata, changed);

574

575

switch (sdata->vif.type) {

575

switch (sdata->vif.type) {

576

case NL80211_IFTYPE_STATION:

576

case NL80211_IFTYPE_STATION:

577

case NL80211_IFTYPE_ADHOC:

577

case NL80211_IFTYPE_ADHOC:

578

case NL80211_IFTYPE_AP:

578

case NL80211_IFTYPE_AP:

579

case NL80211_IFTYPE_MESH_POINT:

579

case NL80211_IFTYPE_MESH_POINT:

580

netif_carrier_off(dev);

580

netif_carrier_off(dev);

581

break;

581

break;

582

case NL80211_IFTYPE_WDS:

582

case NL80211_IFTYPE_WDS:

583

case NL80211_IFTYPE_P2P_DEVICE:

583

case NL80211_IFTYPE_P2P_DEVICE:

584

break;

584

break;

585

default:

585

default:

586

netif_carrier_on(dev);

586

netif_carrier_on(dev);

587

}

587

}

588

589

/*

589

/*

590

* set default queue parameters so drivers don't

590

* set default queue parameters so drivers don't

591

* need to initialise the hardware if the hardware

591

* need to initialise the hardware if the hardware

592

* doesn't start up with sane defaults

592

* doesn't start up with sane defaults

593

*/

593

*/

594

ieee80211_set_wmm_default(sdata, true);

594

ieee80211_set_wmm_default(sdata, true);

595

}

595

}

596

597

set_bit(SDATA_STATE_RUNNING, &sdata->state);

597

set_bit(SDATA_STATE_RUNNING, &sdata->state);

598

599

if (sdata->vif.type == NL80211_IFTYPE_WDS) {

599

if (sdata->vif.type == NL80211_IFTYPE_WDS) {

600

/* Create STA entry for the WDS peer */

600

/* Create STA entry for the WDS peer */

601

sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,

601

sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,

602

GFP_KERNEL);

602

GFP_KERNEL);

603

if (!sta) {

603

if (!sta) {

604

res = -ENOMEM;

604

res = -ENOMEM;

605

goto err_del_interface;

605

goto err_del_interface;

606

}

606

}

607

608

sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);

608

sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);

609

sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);

609

sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);

610

sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);

610

sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);

611

612

res = sta_info_insert(sta);

612

res = sta_info_insert(sta);

613

if (res) {

613

if (res) {

614

/* STA has been freed */

614

/* STA has been freed */

615

goto err_del_interface;

615

goto err_del_interface;

616

}

616

}

617

618

rate_control_rate_init(sta);

618

rate_control_rate_init(sta);

619

netif_carrier_on(dev);

619

netif_carrier_on(dev);

620

} else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {

620

} else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {

621

rcu_assign_pointer(local->p2p_sdata, sdata);

621

rcu_assign_pointer(local->p2p_sdata, sdata);

622

}

622

}

623

624

/*

624

/*

625

* set_multicast_list will be invoked by the networking core

625

* set_multicast_list will be invoked by the networking core

626

* which will check whether any increments here were done in

626

* which will check whether any increments here were done in

627

* error and sync them down to the hardware as filter flags.

627

* error and sync them down to the hardware as filter flags.

628

*/

628

*/

629

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

629

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

630

atomic_inc(&local->iff_allmultis);

630

atomic_inc(&local->iff_allmultis);

631

632

if (sdata->flags & IEEE80211_SDATA_PROMISC)

632

if (sdata->flags & IEEE80211_SDATA_PROMISC)

633

atomic_inc(&local->iff_promiscs);

633

atomic_inc(&local->iff_promiscs);

634

635

if (coming_up)

635

if (coming_up)

636

local->open_count++;

636

local->open_count++;

637

638

if (hw_reconf_flags)

638

if (hw_reconf_flags)

639

ieee80211_hw_config(local, hw_reconf_flags);

639

ieee80211_hw_config(local, hw_reconf_flags);

640

641

ieee80211_recalc_ps(local, -1);

641

ieee80211_recalc_ps(local, -1);

642

643

if (dev)

643

if (dev)

644

netif_tx_start_all_queues(dev);

644

netif_tx_start_all_queues(dev);

645

646

return 0;

646

return 0;

647

err_del_interface:

647

err_del_interface:

648

drv_remove_interface(local, sdata);

648

drv_remove_interface(local, sdata);

649

err_stop:

649

err_stop:

650

if (!local->open_count)

650

if (!local->open_count)

651

drv_stop(local);

651

drv_stop(local);

652

err_del_bss:

652

err_del_bss:

653

sdata->bss = NULL;

653

sdata->bss = NULL;

654

if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)

654

if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)

655

list_del(&sdata->u.vlan.list);

655

list_del(&sdata->u.vlan.list);

656

/* might already be clear but that doesn't matter */

656

/* might already be clear but that doesn't matter */

657

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

657

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

658

return res;

658

return res;

659

}

659

}

660

661

static int ieee80211_open(struct net_device *dev)

661

static int ieee80211_open(struct net_device *dev)

662

{

662

{

663

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

663

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

664

int err;

664

int err;

665

666

/* fail early if user set an invalid address */

666

/* fail early if user set an invalid address */

667

if (!is_valid_ether_addr(dev->dev_addr))

667

if (!is_valid_ether_addr(dev->dev_addr))

668

return -EADDRNOTAVAIL;

668

return -EADDRNOTAVAIL;

669

670

err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);

670

err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);

671

if (err)

671

if (err)

672

return err;

672

return err;

673

674

return ieee80211_do_open(&sdata->wdev, true);

674

return ieee80211_do_open(&sdata->wdev, true);

675

}

675

}

676

677

static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,

677

static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,

678

bool going_down)

678

bool going_down)

679

{

679

{

680

struct ieee80211_local *local = sdata->local;

680

struct ieee80211_local *local = sdata->local;

681

unsigned long flags;

681

unsigned long flags;

682

struct sk_buff *skb, *tmp;

682

struct sk_buff *skb, *tmp;

683

u32 hw_reconf_flags = 0;

683

u32 hw_reconf_flags = 0;

684

int i, flushed;

684

int i, flushed;

685

struct ps_data *ps;

685

struct ps_data *ps;

686

687

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

687

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

688

689

if (rcu_access_pointer(local->scan_sdata) == sdata)

689

if (rcu_access_pointer(local->scan_sdata) == sdata)

690

ieee80211_scan_cancel(local);

690

ieee80211_scan_cancel(local);

691

692

/*

692

/*

693

* Stop TX on this interface first.

693

* Stop TX on this interface first.

694

*/

694

*/

695

if (sdata->dev)

695

if (sdata->dev)

696

netif_tx_stop_all_queues(sdata->dev);

696

netif_tx_stop_all_queues(sdata->dev);

697

698

ieee80211_roc_purge(sdata);

698

ieee80211_roc_purge(sdata);

699

700

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

700

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

701

ieee80211_mgd_stop(sdata);

701

ieee80211_mgd_stop(sdata);

702

703

/*

703

/*

704

* Remove all stations associated with this interface.

704

* Remove all stations associated with this interface.

705

*

705

*

706

* This must be done before calling ops->remove_interface()

706

* This must be done before calling ops->remove_interface()

707

* because otherwise we can later invoke ops->sta_notify()

707

* because otherwise we can later invoke ops->sta_notify()

708

* whenever the STAs are removed, and that invalidates driver

708

* whenever the STAs are removed, and that invalidates driver

709

* assumptions about always getting a vif pointer that is valid

709

* assumptions about always getting a vif pointer that is valid

710

* (because if we remove a STA after ops->remove_interface()

710

* (because if we remove a STA after ops->remove_interface()

711

* the driver will have removed the vif info already!)

711

* the driver will have removed the vif info already!)

712

*

712

*

713

* This is relevant only in WDS mode, in all other modes we've

713

* This is relevant only in WDS mode, in all other modes we've

714

* already removed all stations when disconnecting or similar,

714

* already removed all stations when disconnecting or similar,

715

* so warn otherwise.

715

* so warn otherwise.

716

*

716

*

717

* We call sta_info_flush_cleanup() later, to combine RCU waits.

717

* We call sta_info_flush_cleanup() later, to combine RCU waits.

718

*/

718

*/

719

flushed = sta_info_flush_defer(sdata);

719

flushed = sta_info_flush_defer(sdata);

720

WARN_ON_ONCE((sdata->vif.type != NL80211_IFTYPE_WDS && flushed > 0) ||

720

WARN_ON_ONCE((sdata->vif.type != NL80211_IFTYPE_WDS && flushed > 0) ||

721

(sdata->vif.type == NL80211_IFTYPE_WDS && flushed != 1));

721

(sdata->vif.type == NL80211_IFTYPE_WDS && flushed != 1));

722

723

/*

723

/*

724

* Don't count this interface for promisc/allmulti while it

724

* Don't count this interface for promisc/allmulti while it

725

* is down. dev_mc_unsync() will invoke set_multicast_list

725

* is down. dev_mc_unsync() will invoke set_multicast_list

726

* on the master interface which will sync these down to the

726

* on the master interface which will sync these down to the

727

* hardware as filter flags.

727

* hardware as filter flags.

728

*/

728

*/

729

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

729

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

730

atomic_dec(&local->iff_allmultis);

730

atomic_dec(&local->iff_allmultis);

731

732

if (sdata->flags & IEEE80211_SDATA_PROMISC)

732

if (sdata->flags & IEEE80211_SDATA_PROMISC)

733

atomic_dec(&local->iff_promiscs);

733

atomic_dec(&local->iff_promiscs);

734

735

if (sdata->vif.type == NL80211_IFTYPE_AP) {

735

if (sdata->vif.type == NL80211_IFTYPE_AP) {

736

local->fif_pspoll--;

736

local->fif_pspoll--;

737

local->fif_probe_req--;

737

local->fif_probe_req--;

738

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

738

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

739

local->fif_probe_req--;

739

local->fif_probe_req--;

740

}

740

}

741

742

if (sdata->dev) {

742

if (sdata->dev) {

743

netif_addr_lock_bh(sdata->dev);

743

netif_addr_lock_bh(sdata->dev);

744

spin_lock_bh(&local->filter_lock);

744

spin_lock_bh(&local->filter_lock);

745

__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,

745

__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,

746

sdata->dev->addr_len);

746

sdata->dev->addr_len);

747

spin_unlock_bh(&local->filter_lock);

747

spin_unlock_bh(&local->filter_lock);

748

netif_addr_unlock_bh(sdata->dev);

748

netif_addr_unlock_bh(sdata->dev);

749

750

ieee80211_configure_filter(local);

750

ieee80211_configure_filter(local);

751

}

751

}

752

753

del_timer_sync(&local->dynamic_ps_timer);

753

del_timer_sync(&local->dynamic_ps_timer);

754

cancel_work_sync(&local->dynamic_ps_enable_work);

754

cancel_work_sync(&local->dynamic_ps_enable_work);

755

756

cancel_work_sync(&sdata->recalc_smps);

756

cancel_work_sync(&sdata->recalc_smps);

757

758

cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);

758

cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);

759

760

if (sdata->wdev.cac_started) {

760

if (sdata->wdev.cac_started) {

761

mutex_lock(&local->iflist_mtx);

761

mutex_lock(&local->iflist_mtx);

762

ieee80211_vif_release_channel(sdata);

762

ieee80211_vif_release_channel(sdata);

763

mutex_unlock(&local->iflist_mtx);

763

mutex_unlock(&local->iflist_mtx);

764

cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,

764

cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,

765

GFP_KERNEL);

765

GFP_KERNEL);

766

}

766

}

767

768

/* APs need special treatment */

768

/* APs need special treatment */

769

if (sdata->vif.type == NL80211_IFTYPE_AP) {

769

if (sdata->vif.type == NL80211_IFTYPE_AP) {

770

struct ieee80211_sub_if_data *vlan, *tmpsdata;

770

struct ieee80211_sub_if_data *vlan, *tmpsdata;

771

772

/* down all dependent devices, that is VLANs */

772

/* down all dependent devices, that is VLANs */

773

list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,

773

list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,

774

u.vlan.list)

774

u.vlan.list)

775

dev_close(vlan->dev);

775

dev_close(vlan->dev);

776

WARN_ON(!list_empty(&sdata->u.ap.vlans));

776

WARN_ON(!list_empty(&sdata->u.ap.vlans));

777

} else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {

777

} else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {

778

/* remove all packets in parent bc_buf pointing to this dev */

778

/* remove all packets in parent bc_buf pointing to this dev */

779

ps = &sdata->bss->ps;

779

ps = &sdata->bss->ps;

780

781

spin_lock_irqsave(&ps->bc_buf.lock, flags);

781

spin_lock_irqsave(&ps->bc_buf.lock, flags);

782

skb_queue_walk_safe(&ps->bc_buf, skb, tmp) {

782

skb_queue_walk_safe(&ps->bc_buf, skb, tmp) {

783

if (skb->dev == sdata->dev) {

783

if (skb->dev == sdata->dev) {

784

__skb_unlink(skb, &ps->bc_buf);

784

__skb_unlink(skb, &ps->bc_buf);

785

local->total_ps_buffered--;

785

local->total_ps_buffered--;

786

ieee80211_free_txskb(&local->hw, skb);

786

ieee80211_free_txskb(&local->hw, skb);

787

}

787

}

788

}

788

}

789

spin_unlock_irqrestore(&ps->bc_buf.lock, flags);

789

spin_unlock_irqrestore(&ps->bc_buf.lock, flags);

790

}

790

}

791

792

if (going_down)

792

if (going_down)

793

local->open_count--;

793

local->open_count--;

794

795

switch (sdata->vif.type) {

795

switch (sdata->vif.type) {

796

case NL80211_IFTYPE_AP_VLAN:

796

case NL80211_IFTYPE_AP_VLAN:

797

list_del(&sdata->u.vlan.list);

797

list_del(&sdata->u.vlan.list);

798

rcu_assign_pointer(sdata->vif.chanctx_conf, NULL);

798

rcu_assign_pointer(sdata->vif.chanctx_conf, NULL);

799

/* no need to tell driver */

799

/* no need to tell driver */

800

break;

800

break;

801

case NL80211_IFTYPE_MONITOR:

801

case NL80211_IFTYPE_MONITOR:

802

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

802

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

803

local->cooked_mntrs--;

803

local->cooked_mntrs--;

804

break;

804

break;

805

}

805

}

806

807

local->monitors--;

807

local->monitors--;

808

if (local->monitors == 0) {

808

if (local->monitors == 0) {

809

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

809

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

810

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

810

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

811

ieee80211_del_virtual_monitor(local);

811

ieee80211_del_virtual_monitor(local);

812

}

812

}

813

814

ieee80211_adjust_monitor_flags(sdata, -1);

814

ieee80211_adjust_monitor_flags(sdata, -1);

815

ieee80211_configure_filter(local);

815

ieee80211_configure_filter(local);

816

mutex_lock(&local->mtx);

816

mutex_lock(&local->mtx);

817

ieee80211_recalc_idle(local);

817

ieee80211_recalc_idle(local);

818

mutex_unlock(&local->mtx);

818

mutex_unlock(&local->mtx);

819

break;

819

break;

820

case NL80211_IFTYPE_P2P_DEVICE:

820

case NL80211_IFTYPE_P2P_DEVICE:

821

/* relies on synchronize_rcu() below */

821

/* relies on synchronize_rcu() below */

822

rcu_assign_pointer(local->p2p_sdata, NULL);

822

rcu_assign_pointer(local->p2p_sdata, NULL);

823

/* fall through */

823

/* fall through */

824

default:

824

default:

825

cancel_work_sync(&sdata->work);

825

cancel_work_sync(&sdata->work);

826

/*

826

/*

827

* When we get here, the interface is marked down.

827

* When we get here, the interface is marked down.

828

*

828

*

829

* sta_info_flush_cleanup() requires rcu_barrier()

829

* sta_info_flush_cleanup() requires rcu_barrier()

830

* first to wait for the station call_rcu() calls

830

* first to wait for the station call_rcu() calls

831

* to complete, here we need at least sychronize_rcu()

831

* to complete, here we need at least sychronize_rcu()

832

* it to wait for the RX path in case it is using the

832

* it to wait for the RX path in case it is using the

833

* interface and enqueuing frames at this very time on

833

* interface and enqueuing frames at this very time on

834

* another CPU.

834

* another CPU.

835

*/

835

*/

836

rcu_barrier();

836

rcu_barrier();

837

sta_info_flush_cleanup(sdata);

837

sta_info_flush_cleanup(sdata);

838

839

skb_queue_purge(&sdata->skb_queue);

840

841

/*

839

/*

842

* Free all remaining keys, there shouldn't be any,

840

* Free all remaining keys, there shouldn't be any,

843

* except maybe in WDS mode?

841

* except maybe in WDS mode?

844

*/

842

*/

845

ieee80211_free_keys(sdata);

843

ieee80211_free_keys(sdata);

844

845

/* fall through */

846

case NL80211_IFTYPE_AP:

847

skb_queue_purge(&sdata->skb_queue);

846

848

847

drv_remove_interface_debugfs(local, sdata);

849

drv_remove_interface_debugfs(local, sdata);

848

850

849

if (going_down)

851

if (going_down)

850

drv_remove_interface(local, sdata);

852

drv_remove_interface(local, sdata);

851

}

853

}

852

854

853

sdata->bss = NULL;

855

sdata->bss = NULL;

854

856

855

ieee80211_recalc_ps(local, -1);

857

ieee80211_recalc_ps(local, -1);

856

858

857

if (local->open_count == 0) {

859

if (local->open_count == 0) {

858

ieee80211_clear_tx_pending(local);

860

ieee80211_clear_tx_pending(local);

859

ieee80211_stop_device(local);

861

ieee80211_stop_device(local);

860

862

861

/* no reconfiguring after stop! */

863

/* no reconfiguring after stop! */

862

hw_reconf_flags = 0;

864

hw_reconf_flags = 0;

863

}

865

}

864

866

865

/* do after stop to avoid reconfiguring when we stop anyway */

867

/* do after stop to avoid reconfiguring when we stop anyway */

866

if (hw_reconf_flags)

868

if (hw_reconf_flags)

867

ieee80211_hw_config(local, hw_reconf_flags);

869

ieee80211_hw_config(local, hw_reconf_flags);

868

870

869

spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

871

spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

870

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

872

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

871

skb_queue_walk_safe(&local->pending[i], skb, tmp) {

873

skb_queue_walk_safe(&local->pending[i], skb, tmp) {

872

struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

874

struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

873

if (info->control.vif == &sdata->vif) {

875

if (info->control.vif == &sdata->vif) {

874

__skb_unlink(skb, &local->pending[i]);

876

__skb_unlink(skb, &local->pending[i]);

875

ieee80211_free_txskb(&local->hw, skb);

877

ieee80211_free_txskb(&local->hw, skb);

876

}

878

}

877

}

879

}

878

}

880

}

879

spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);

881

spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);

880

882

881

if (local->monitors == local->open_count && local->monitors > 0)

883

if (local->monitors == local->open_count && local->monitors > 0)

882

ieee80211_add_virtual_monitor(local);

884

ieee80211_add_virtual_monitor(local);

883

}

885

}

884

886

885

static int ieee80211_stop(struct net_device *dev)

887

static int ieee80211_stop(struct net_device *dev)

886

{

888

{

887

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

889

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

888

890

889

ieee80211_do_stop(sdata, true);

891

ieee80211_do_stop(sdata, true);

890

892

891

return 0;

893

return 0;

892

}

894

}

893

895

894

static void ieee80211_set_multicast_list(struct net_device *dev)

896

static void ieee80211_set_multicast_list(struct net_device *dev)

895

{

897

{

896

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

898

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

897

struct ieee80211_local *local = sdata->local;

899

struct ieee80211_local *local = sdata->local;

898

int allmulti, promisc, sdata_allmulti, sdata_promisc;

900

int allmulti, promisc, sdata_allmulti, sdata_promisc;

899

901

900

allmulti = !!(dev->flags & IFF_ALLMULTI);

902

allmulti = !!(dev->flags & IFF_ALLMULTI);

901

promisc = !!(dev->flags & IFF_PROMISC);

903

promisc = !!(dev->flags & IFF_PROMISC);

902

sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);

904

sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);

903

sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);

905

sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);

904

906

905

if (allmulti != sdata_allmulti) {

907

if (allmulti != sdata_allmulti) {

906

if (dev->flags & IFF_ALLMULTI)

908

if (dev->flags & IFF_ALLMULTI)

907

atomic_inc(&local->iff_allmultis);

909

atomic_inc(&local->iff_allmultis);

908

else

910

else

909

atomic_dec(&local->iff_allmultis);

911

atomic_dec(&local->iff_allmultis);

910

sdata->flags ^= IEEE80211_SDATA_ALLMULTI;

912

sdata->flags ^= IEEE80211_SDATA_ALLMULTI;

911

}

913

}

912

914

913

if (promisc != sdata_promisc) {

915

if (promisc != sdata_promisc) {

914

if (dev->flags & IFF_PROMISC)

916

if (dev->flags & IFF_PROMISC)

915

atomic_inc(&local->iff_promiscs);

917

atomic_inc(&local->iff_promiscs);

916

else

918

else

917

atomic_dec(&local->iff_promiscs);

919

atomic_dec(&local->iff_promiscs);

918

sdata->flags ^= IEEE80211_SDATA_PROMISC;

920

sdata->flags ^= IEEE80211_SDATA_PROMISC;

919

}

921

}

920

spin_lock_bh(&local->filter_lock);

922

spin_lock_bh(&local->filter_lock);

921

__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);

923

__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);

922

spin_unlock_bh(&local->filter_lock);

924

spin_unlock_bh(&local->filter_lock);

923

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

925

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

924

}

926

}

925

927

926

/*

928

/*

927

* Called when the netdev is removed or, by the code below, before

929

* Called when the netdev is removed or, by the code below, before

928

* the interface type changes.

930

* the interface type changes.

929

*/

931

*/

930

static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)

932

static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)

931

{

933

{

932

int flushed;

934

int flushed;

933

int i;

935

int i;

934

936

935

/* free extra data */

937

/* free extra data */

936

ieee80211_free_keys(sdata);

938

ieee80211_free_keys(sdata);

937

939

938

ieee80211_debugfs_remove_netdev(sdata);

940

ieee80211_debugfs_remove_netdev(sdata);

939

941

940

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

942

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

941

__skb_queue_purge(&sdata->fragments[i].skb_list);

943

__skb_queue_purge(&sdata->fragments[i].skb_list);

942

sdata->fragment_next = 0;

944

sdata->fragment_next = 0;

943

945

944

if (ieee80211_vif_is_mesh(&sdata->vif))

946

if (ieee80211_vif_is_mesh(&sdata->vif))

945

mesh_rmc_free(sdata);

947

mesh_rmc_free(sdata);

946

948

947

flushed = sta_info_flush(sdata);

949

flushed = sta_info_flush(sdata);

948

WARN_ON(flushed);

950

WARN_ON(flushed);

949

}

951

}

950

952

951

static void ieee80211_uninit(struct net_device *dev)

953

static void ieee80211_uninit(struct net_device *dev)

952

{

954

{

953

ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));

955

ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));

954

}

956

}

955

957

956

static u16 ieee80211_netdev_select_queue(struct net_device *dev,

958

static u16 ieee80211_netdev_select_queue(struct net_device *dev,

957

struct sk_buff *skb)

959

struct sk_buff *skb)

958

{

960

{

959

return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);

961

return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);

960

}

962

}

961

963

962

static const struct net_device_ops ieee80211_dataif_ops = {

964

static const struct net_device_ops ieee80211_dataif_ops = {

963

.ndo_open = ieee80211_open,

965

.ndo_open = ieee80211_open,

964

.ndo_stop = ieee80211_stop,

966

.ndo_stop = ieee80211_stop,

965

.ndo_uninit = ieee80211_uninit,

967

.ndo_uninit = ieee80211_uninit,

966

.ndo_start_xmit = ieee80211_subif_start_xmit,

968

.ndo_start_xmit = ieee80211_subif_start_xmit,

967

.ndo_set_rx_mode = ieee80211_set_multicast_list,

969

.ndo_set_rx_mode = ieee80211_set_multicast_list,

968

.ndo_change_mtu = ieee80211_change_mtu,

970

.ndo_change_mtu = ieee80211_change_mtu,

969

.ndo_set_mac_address = ieee80211_change_mac,

971

.ndo_set_mac_address = ieee80211_change_mac,

970

.ndo_select_queue = ieee80211_netdev_select_queue,

972

.ndo_select_queue = ieee80211_netdev_select_queue,

971

};

973

};

972

974

973

static u16 ieee80211_monitor_select_queue(struct net_device *dev,

975

static u16 ieee80211_monitor_select_queue(struct net_device *dev,

974

struct sk_buff *skb)

976

struct sk_buff *skb)

975

{

977

{

976

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

978

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

977

struct ieee80211_local *local = sdata->local;

979

struct ieee80211_local *local = sdata->local;

978

struct ieee80211_hdr *hdr;

980

struct ieee80211_hdr *hdr;

979

struct ieee80211_radiotap_header *rtap = (void *)skb->data;

981

struct ieee80211_radiotap_header *rtap = (void *)skb->data;

980

982

981

if (local->hw.queues < IEEE80211_NUM_ACS)

983

if (local->hw.queues < IEEE80211_NUM_ACS)

982

return 0;

984

return 0;

983

985

984

if (skb->len < 4 ||

986

if (skb->len < 4 ||

985

skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)

987

skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)

986

return 0; /* doesn't matter, frame will be dropped */

988

return 0; /* doesn't matter, frame will be dropped */

987

989

988

hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));

990

hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));

989

991

990

return ieee80211_select_queue_80211(sdata, skb, hdr);

992

return ieee80211_select_queue_80211(sdata, skb, hdr);

991

}

993

}

992

994

993

static const struct net_device_ops ieee80211_monitorif_ops = {

995

static const struct net_device_ops ieee80211_monitorif_ops = {

994

.ndo_open = ieee80211_open,

996

.ndo_open = ieee80211_open,

995

.ndo_stop = ieee80211_stop,

997

.ndo_stop = ieee80211_stop,

996

.ndo_uninit = ieee80211_uninit,

998

.ndo_uninit = ieee80211_uninit,

997

.ndo_start_xmit = ieee80211_monitor_start_xmit,

999

.ndo_start_xmit = ieee80211_monitor_start_xmit,

998

.ndo_set_rx_mode = ieee80211_set_multicast_list,

1000

.ndo_set_rx_mode = ieee80211_set_multicast_list,

999

.ndo_change_mtu = ieee80211_change_mtu,

1001

.ndo_change_mtu = ieee80211_change_mtu,

1000

.ndo_set_mac_address = eth_mac_addr,

1002

.ndo_set_mac_address = eth_mac_addr,

1001

.ndo_select_queue = ieee80211_monitor_select_queue,

1003

.ndo_select_queue = ieee80211_monitor_select_queue,

1002

};

1004

};

1003

1005

1004

static void ieee80211_if_setup(struct net_device *dev)

1006

static void ieee80211_if_setup(struct net_device *dev)

1005

{

1007

{

1006

ether_setup(dev);

1008

ether_setup(dev);

1007

dev->priv_flags &= ~IFF_TX_SKB_SHARING;

1009

dev->priv_flags &= ~IFF_TX_SKB_SHARING;

1008

dev->netdev_ops = &ieee80211_dataif_ops;

1010

dev->netdev_ops = &ieee80211_dataif_ops;

1009

dev->destructor = free_netdev;

1011

dev->destructor = free_netdev;

1010

}

1012

}

1011

1013

1012

static void ieee80211_iface_work(struct work_struct *work)

1014

static void ieee80211_iface_work(struct work_struct *work)

1013

{

1015

{

1014

struct ieee80211_sub_if_data *sdata =

1016

struct ieee80211_sub_if_data *sdata =

1015

container_of(work, struct ieee80211_sub_if_data, work);

1017

container_of(work, struct ieee80211_sub_if_data, work);

1016

struct ieee80211_local *local = sdata->local;

1018

struct ieee80211_local *local = sdata->local;

1017

struct sk_buff *skb;

1019

struct sk_buff *skb;

1018

struct sta_info *sta;

1020

struct sta_info *sta;

1019

struct ieee80211_ra_tid *ra_tid;

1021

struct ieee80211_ra_tid *ra_tid;

1020

1022

1021

if (!ieee80211_sdata_running(sdata))

1023

if (!ieee80211_sdata_running(sdata))

1022

return;

1024

return;

1023

1025

1024

if (local->scanning)

1026

if (local->scanning)

1025

return;

1027

return;

1026

1028

1027

/*

1029

/*

1028

* ieee80211_queue_work() should have picked up most cases,

1030

* ieee80211_queue_work() should have picked up most cases,

1029

* here we'll pick the rest.

1031

* here we'll pick the rest.

1030

*/

1032

*/

1031

if (WARN(local->suspended,

1033

if (WARN(local->suspended,

1032

"interface work scheduled while going to suspend\n"))

1034

"interface work scheduled while going to suspend\n"))

1033

return;

1035

return;

1034

1036

1035

/* first process frames */

1037

/* first process frames */

1036

while ((skb = skb_dequeue(&sdata->skb_queue))) {

1038

while ((skb = skb_dequeue(&sdata->skb_queue))) {

1037

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

1039

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

1038

1040

1039

if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {

1041

if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {

1040

ra_tid = (void *)&skb->cb;

1042

ra_tid = (void *)&skb->cb;

1041

ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,

1043

ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,

1042

ra_tid->tid);

1044

ra_tid->tid);

1043

} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {

1045

} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {

1044

ra_tid = (void *)&skb->cb;

1046

ra_tid = (void *)&skb->cb;

1045

ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,

1047

ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,

1046

ra_tid->tid);

1048

ra_tid->tid);

1047

} else if (ieee80211_is_action(mgmt->frame_control) &&

1049

} else if (ieee80211_is_action(mgmt->frame_control) &&

1048

mgmt->u.action.category == WLAN_CATEGORY_BACK) {

1050

mgmt->u.action.category == WLAN_CATEGORY_BACK) {

1049

int len = skb->len;

1051

int len = skb->len;

1050

1052

1051

mutex_lock(&local->sta_mtx);

1053

mutex_lock(&local->sta_mtx);

1052

sta = sta_info_get_bss(sdata, mgmt->sa);

1054

sta = sta_info_get_bss(sdata, mgmt->sa);

1053

if (sta) {

1055

if (sta) {

1054

switch (mgmt->u.action.u.addba_req.action_code) {

1056

switch (mgmt->u.action.u.addba_req.action_code) {

1055

case WLAN_ACTION_ADDBA_REQ:

1057

case WLAN_ACTION_ADDBA_REQ:

1056

ieee80211_process_addba_request(

1058

ieee80211_process_addba_request(

1057

local, sta, mgmt, len);

1059

local, sta, mgmt, len);

1058

break;

1060

break;

1059

case WLAN_ACTION_ADDBA_RESP:

1061

case WLAN_ACTION_ADDBA_RESP:

1060

ieee80211_process_addba_resp(local, sta,

1062

ieee80211_process_addba_resp(local, sta,

1061

mgmt, len);

1063

mgmt, len);

1062

break;

1064

break;

1063

case WLAN_ACTION_DELBA:

1065

case WLAN_ACTION_DELBA:

1064

ieee80211_process_delba(sdata, sta,

1066

ieee80211_process_delba(sdata, sta,

1065

mgmt, len);

1067

mgmt, len);

1066

break;

1068

break;

1067

default:

1069

default:

1068

WARN_ON(1);

1070

WARN_ON(1);

1069

break;

1071

break;

1070

}

1072

}

1071

}

1073

}

1072

mutex_unlock(&local->sta_mtx);

1074

mutex_unlock(&local->sta_mtx);

1073

} else if (ieee80211_is_data_qos(mgmt->frame_control)) {

1075

} else if (ieee80211_is_data_qos(mgmt->frame_control)) {

1074

struct ieee80211_hdr *hdr = (void *)mgmt;

1076

struct ieee80211_hdr *hdr = (void *)mgmt;

1075

/*

1077

/*

1076

* So the frame isn't mgmt, but frame_control

1078

* So the frame isn't mgmt, but frame_control

1077

* is at the right place anyway, of course, so

1079

* is at the right place anyway, of course, so

1078

* the if statement is correct.

1080

* the if statement is correct.

1079

*

1081

*

1080

* Warn if we have other data frame types here,

1082

* Warn if we have other data frame types here,

1081

* they must not get here.

1083

* they must not get here.

1082

*/

1084

*/

1083

WARN_ON(hdr->frame_control &

1085

WARN_ON(hdr->frame_control &

1084

cpu_to_le16(IEEE80211_STYPE_NULLFUNC));

1086

cpu_to_le16(IEEE80211_STYPE_NULLFUNC));

1085

WARN_ON(!(hdr->seq_ctrl &

1087

WARN_ON(!(hdr->seq_ctrl &

1086

cpu_to_le16(IEEE80211_SCTL_FRAG)));

1088

cpu_to_le16(IEEE80211_SCTL_FRAG)));

1087

/*

1089

/*

1088

* This was a fragment of a frame, received while

1090

* This was a fragment of a frame, received while

1089

* a block-ack session was active. That cannot be

1091

* a block-ack session was active. That cannot be

1090

* right, so terminate the session.

1092

* right, so terminate the session.

1091

*/

1093

*/

1092

mutex_lock(&local->sta_mtx);

1094

mutex_lock(&local->sta_mtx);

1093

sta = sta_info_get_bss(sdata, mgmt->sa);

1095

sta = sta_info_get_bss(sdata, mgmt->sa);

1094

if (sta) {

1096

if (sta) {

1095

u16 tid = *ieee80211_get_qos_ctl(hdr) &

1097

u16 tid = *ieee80211_get_qos_ctl(hdr) &

1096

IEEE80211_QOS_CTL_TID_MASK;

1098

IEEE80211_QOS_CTL_TID_MASK;

1097

1099

1098

__ieee80211_stop_rx_ba_session(

1100

__ieee80211_stop_rx_ba_session(

1099

sta, tid, WLAN_BACK_RECIPIENT,

1101

sta, tid, WLAN_BACK_RECIPIENT,

1100

WLAN_REASON_QSTA_REQUIRE_SETUP,

1102

WLAN_REASON_QSTA_REQUIRE_SETUP,

1101

true);

1103

true);

1102

}

1104

}

1103

mutex_unlock(&local->sta_mtx);

1105

mutex_unlock(&local->sta_mtx);

1104

} else switch (sdata->vif.type) {

1106

} else switch (sdata->vif.type) {

1105

case NL80211_IFTYPE_STATION:

1107

case NL80211_IFTYPE_STATION:

1106

ieee80211_sta_rx_queued_mgmt(sdata, skb);

1108

ieee80211_sta_rx_queued_mgmt(sdata, skb);

1107

break;

1109

break;

1108

case NL80211_IFTYPE_ADHOC:

1110

case NL80211_IFTYPE_ADHOC:

1109

ieee80211_ibss_rx_queued_mgmt(sdata, skb);

1111

ieee80211_ibss_rx_queued_mgmt(sdata, skb);

1110

break;

1112

break;

1111

case NL80211_IFTYPE_MESH_POINT:

1113

case NL80211_IFTYPE_MESH_POINT:

1112

if (!ieee80211_vif_is_mesh(&sdata->vif))

1114

if (!ieee80211_vif_is_mesh(&sdata->vif))

1113

break;

1115

break;

1114

ieee80211_mesh_rx_queued_mgmt(sdata, skb);

1116

ieee80211_mesh_rx_queued_mgmt(sdata, skb);

1115

break;

1117

break;

1116

default:

1118

default:

1117

WARN(1, "frame for unexpected interface type");

1119

WARN(1, "frame for unexpected interface type");

1118

break;

1120

break;

1119

}

1121

}

1120

1122

1121

kfree_skb(skb);

1123

kfree_skb(skb);

1122

}

1124

}

1123

1125

1124

/* then other type-dependent work */

1126

/* then other type-dependent work */

1125

switch (sdata->vif.type) {

1127

switch (sdata->vif.type) {

1126

case NL80211_IFTYPE_STATION:

1128

case NL80211_IFTYPE_STATION:

1127

ieee80211_sta_work(sdata);

1129

ieee80211_sta_work(sdata);

1128

break;

1130

break;

1129

case NL80211_IFTYPE_ADHOC:

1131

case NL80211_IFTYPE_ADHOC:

1130

ieee80211_ibss_work(sdata);

1132

ieee80211_ibss_work(sdata);

1131

break;

1133

break;

1132

case NL80211_IFTYPE_MESH_POINT:

1134

case NL80211_IFTYPE_MESH_POINT:

1133

if (!ieee80211_vif_is_mesh(&sdata->vif))

1135

if (!ieee80211_vif_is_mesh(&sdata->vif))

1134

break;

1136

break;

1135

ieee80211_mesh_work(sdata);

1137

ieee80211_mesh_work(sdata);

1136

break;

1138

break;

1137

default:

1139

default:

1138

break;

1140

break;

1139

}

1141

}

1140

}

1142

}

1141

1143

1142

static void ieee80211_recalc_smps_work(struct work_struct *work)

1144

static void ieee80211_recalc_smps_work(struct work_struct *work)

1143

{

1145

{

1144

struct ieee80211_sub_if_data *sdata =

1146

struct ieee80211_sub_if_data *sdata =

1145

container_of(work, struct ieee80211_sub_if_data, recalc_smps);

1147

container_of(work, struct ieee80211_sub_if_data, recalc_smps);

1146

1148

1147

ieee80211_recalc_smps(sdata);

1149

ieee80211_recalc_smps(sdata);

1148

}

1150

}

1149

1151

1150

/*

1152

/*

1151

* Helper function to initialise an interface to a specific type.

1153

* Helper function to initialise an interface to a specific type.

1152

*/

1154

*/

1153

static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,

1155

static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,

1154

enum nl80211_iftype type)

1156

enum nl80211_iftype type)

1155

{

1157

{

1156

/* clear type-dependent union */

1158

/* clear type-dependent union */

1157

memset(&sdata->u, 0, sizeof(sdata->u));

1159

memset(&sdata->u, 0, sizeof(sdata->u));

1158

1160

1159

/* and set some type-dependent values */

1161

/* and set some type-dependent values */

1160

sdata->vif.type = type;

1162

sdata->vif.type = type;

1161

sdata->vif.p2p = false;

1163

sdata->vif.p2p = false;

1162

sdata->wdev.iftype = type;

1164

sdata->wdev.iftype = type;

1163

1165

1164

sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);

1166

sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);

1165

sdata->control_port_no_encrypt = false;

1167

sdata->control_port_no_encrypt = false;

1166

1168

1167

sdata->noack_map = 0;

1169

sdata->noack_map = 0;

1168

1170

1169

/* only monitor/p2p-device differ */

1171

/* only monitor/p2p-device differ */

1170

if (sdata->dev) {

1172

if (sdata->dev) {

1171

sdata->dev->netdev_ops = &ieee80211_dataif_ops;

1173

sdata->dev->netdev_ops = &ieee80211_dataif_ops;

1172

sdata->dev->type = ARPHRD_ETHER;

1174

sdata->dev->type = ARPHRD_ETHER;

1173

}

1175

}

1174

1176

1175

skb_queue_head_init(&sdata->skb_queue);

1177

skb_queue_head_init(&sdata->skb_queue);

1176

INIT_WORK(&sdata->work, ieee80211_iface_work);

1178

INIT_WORK(&sdata->work, ieee80211_iface_work);

1177

INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);

1179

INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);

1178

1180

1179

switch (type) {

1181

switch (type) {

1180

case NL80211_IFTYPE_P2P_GO:

1182

case NL80211_IFTYPE_P2P_GO:

1181

type = NL80211_IFTYPE_AP;

1183

type = NL80211_IFTYPE_AP;

1182

sdata->vif.type = type;

1184

sdata->vif.type = type;

1183

sdata->vif.p2p = true;

1185

sdata->vif.p2p = true;

1184

/* fall through */

1186

/* fall through */

1185

case NL80211_IFTYPE_AP:

1187

case NL80211_IFTYPE_AP:

1186

skb_queue_head_init(&sdata->u.ap.ps.bc_buf);

1188

skb_queue_head_init(&sdata->u.ap.ps.bc_buf);

1187

INIT_LIST_HEAD(&sdata->u.ap.vlans);

1189

INIT_LIST_HEAD(&sdata->u.ap.vlans);

1188

sdata->vif.bss_conf.bssid = sdata->vif.addr;

1190

sdata->vif.bss_conf.bssid = sdata->vif.addr;

1189

break;

1191

break;

1190

case NL80211_IFTYPE_P2P_CLIENT:

1192

case NL80211_IFTYPE_P2P_CLIENT:

1191

type = NL80211_IFTYPE_STATION;

1193

type = NL80211_IFTYPE_STATION;

1192

sdata->vif.type = type;

1194

sdata->vif.type = type;

1193

sdata->vif.p2p = true;

1195

sdata->vif.p2p = true;

1194

/* fall through */

1196

/* fall through */

1195

case NL80211_IFTYPE_STATION:

1197

case NL80211_IFTYPE_STATION:

1196

sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;

1198

sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;

1197

ieee80211_sta_setup_sdata(sdata);

1199

ieee80211_sta_setup_sdata(sdata);

1198

break;

1200

break;

1199

case NL80211_IFTYPE_ADHOC:

1201

case NL80211_IFTYPE_ADHOC:

1200

sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;

1202

sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;

1201

ieee80211_ibss_setup_sdata(sdata);

1203

ieee80211_ibss_setup_sdata(sdata);

1202

break;

1204

break;

1203

case NL80211_IFTYPE_MESH_POINT:

1205

case NL80211_IFTYPE_MESH_POINT:

1204

if (ieee80211_vif_is_mesh(&sdata->vif))

1206

if (ieee80211_vif_is_mesh(&sdata->vif))

1205

ieee80211_mesh_init_sdata(sdata);

1207

ieee80211_mesh_init_sdata(sdata);

1206

break;

1208

break;

1207

case NL80211_IFTYPE_MONITOR:

1209

case NL80211_IFTYPE_MONITOR:

1208

sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;

1210

sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;

1209

sdata->dev->netdev_ops = &ieee80211_monitorif_ops;

1211

sdata->dev->netdev_ops = &ieee80211_monitorif_ops;

1210

sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |

1212

sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |

1211

MONITOR_FLAG_OTHER_BSS;

1213

MONITOR_FLAG_OTHER_BSS;

1212

break;

1214

break;

1213

case NL80211_IFTYPE_WDS:

1215

case NL80211_IFTYPE_WDS:

1214

sdata->vif.bss_conf.bssid = NULL;

1216

sdata->vif.bss_conf.bssid = NULL;

1215

break;

1217

break;

1216

case NL80211_IFTYPE_AP_VLAN:

1218

case NL80211_IFTYPE_AP_VLAN:

1217

break;

1219

break;

1218

case NL80211_IFTYPE_P2P_DEVICE:

1220

case NL80211_IFTYPE_P2P_DEVICE:

1219

sdata->vif.bss_conf.bssid = sdata->vif.addr;

1221

sdata->vif.bss_conf.bssid = sdata->vif.addr;

1220

break;

1222

break;

1221

case NL80211_IFTYPE_UNSPECIFIED:

1223

case NL80211_IFTYPE_UNSPECIFIED:

1222

case NUM_NL80211_IFTYPES:

1224

case NUM_NL80211_IFTYPES:

1223

BUG();

1225

BUG();

1224

break;

1226

break;

1225

}

1227

}

1226

1228

1227

ieee80211_debugfs_add_netdev(sdata);

1229

ieee80211_debugfs_add_netdev(sdata);

1228

}

1230

}

1229

1231

1230

static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,

1232

static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,

1231

enum nl80211_iftype type)

1233

enum nl80211_iftype type)

1232

{

1234

{

1233

struct ieee80211_local *local = sdata->local;

1235

struct ieee80211_local *local = sdata->local;

1234

int ret, err;

1236

int ret, err;

1235

enum nl80211_iftype internal_type = type;

1237

enum nl80211_iftype internal_type = type;

1236

bool p2p = false;

1238

bool p2p = false;

1237

1239

1238

ASSERT_RTNL();

1240

ASSERT_RTNL();

1239

1241

1240

if (!local->ops->change_interface)

1242

if (!local->ops->change_interface)

1241

return -EBUSY;

1243

return -EBUSY;

1242

1244

1243

switch (sdata->vif.type) {

1245

switch (sdata->vif.type) {

1244

case NL80211_IFTYPE_AP:

1246

case NL80211_IFTYPE_AP:

1245

case NL80211_IFTYPE_STATION:

1247

case NL80211_IFTYPE_STATION:

1246

case NL80211_IFTYPE_ADHOC:

1248

case NL80211_IFTYPE_ADHOC:

1247

/*

1249

/*

1248

* Could maybe also all others here?

1250

* Could maybe also all others here?

1249

* Just not sure how that interacts

1251

* Just not sure how that interacts

1250

* with the RX/config path e.g. for

1252

* with the RX/config path e.g. for

1251

* mesh.

1253

* mesh.

1252

*/

1254

*/

1253

break;

1255

break;

1254

default:

1256

default:

1255

return -EBUSY;

1257

return -EBUSY;

1256

}

1258

}

1257

1259

1258

switch (type) {

1260

switch (type) {

1259

case NL80211_IFTYPE_AP:

1261

case NL80211_IFTYPE_AP:

1260

case NL80211_IFTYPE_STATION:

1262

case NL80211_IFTYPE_STATION:

1261

case NL80211_IFTYPE_ADHOC:

1263

case NL80211_IFTYPE_ADHOC:

1262

/*

1264

/*

1263

* Could probably support everything

1265

* Could probably support everything

1264

* but WDS here (WDS do_open can fail

1266

* but WDS here (WDS do_open can fail

1265

* under memory pressure, which this

1267

* under memory pressure, which this

1266

* code isn't prepared to handle).

1268

* code isn't prepared to handle).

1267

*/

1269

*/

1268

break;

1270

break;

1269

case NL80211_IFTYPE_P2P_CLIENT:

1271

case NL80211_IFTYPE_P2P_CLIENT:

1270

p2p = true;

1272

p2p = true;

1271

internal_type = NL80211_IFTYPE_STATION;

1273

internal_type = NL80211_IFTYPE_STATION;

1272

break;

1274

break;

1273

case NL80211_IFTYPE_P2P_GO:

1275

case NL80211_IFTYPE_P2P_GO:

1274

p2p = true;

1276

p2p = true;

1275

internal_type = NL80211_IFTYPE_AP;

1277

internal_type = NL80211_IFTYPE_AP;

1276

break;

1278

break;

1277

default:

1279

default:

1278

return -EBUSY;

1280

return -EBUSY;

1279

}

1281

}

1280

1282

1281

ret = ieee80211_check_concurrent_iface(sdata, internal_type);

1283

ret = ieee80211_check_concurrent_iface(sdata, internal_type);

1282

if (ret)

1284

if (ret)

1283

return ret;

1285

return ret;

1284

1286

1285

ieee80211_do_stop(sdata, false);

1287

ieee80211_do_stop(sdata, false);

1286

1288

1287

ieee80211_teardown_sdata(sdata);

1289

ieee80211_teardown_sdata(sdata);

1288

1290

1289

ret = drv_change_interface(local, sdata, internal_type, p2p);

1291

ret = drv_change_interface(local, sdata, internal_type, p2p);

1290

if (ret)

1292

if (ret)

1291

type = sdata->vif.type;

1293

type = sdata->vif.type;

1292

1294

1293

/*

1295

/*

1294

* Ignore return value here, there's not much we can do since

1296

* Ignore return value here, there's not much we can do since

1295

* the driver changed the interface type internally already.

1297

* the driver changed the interface type internally already.

1296

* The warnings will hopefully make driver authors fix it :-)

1298

* The warnings will hopefully make driver authors fix it :-)

1297

*/

1299

*/

1298

ieee80211_check_queues(sdata);

1300

ieee80211_check_queues(sdata);

1299

1301

1300

ieee80211_setup_sdata(sdata, type);

1302

ieee80211_setup_sdata(sdata, type);

1301

1303

1302

err = ieee80211_do_open(&sdata->wdev, false);

1304

err = ieee80211_do_open(&sdata->wdev, false);

1303

WARN(err, "type change: do_open returned %d", err);

1305

WARN(err, "type change: do_open returned %d", err);

1304

1306

1305

return ret;

1307

return ret;

1306

}

1308

}

1307

1309

1308

int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,

1310

int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,

1309

enum nl80211_iftype type)

1311

enum nl80211_iftype type)

1310

{

1312

{

1311

int ret;

1313

int ret;

1312

1314

1313

ASSERT_RTNL();

1315

ASSERT_RTNL();

1314

1316

1315

if (type == ieee80211_vif_type_p2p(&sdata->vif))

1317

if (type == ieee80211_vif_type_p2p(&sdata->vif))

1316

return 0;

1318

return 0;

1317

1319

1318

if (ieee80211_sdata_running(sdata)) {

1320

if (ieee80211_sdata_running(sdata)) {

1319

ret = ieee80211_runtime_change_iftype(sdata, type);

1321

ret = ieee80211_runtime_change_iftype(sdata, type);

1320

if (ret)

1322

if (ret)

1321

return ret;

1323

return ret;

1322

} else {

1324

} else {

1323

/* Purge and reset type-dependent state. */

1325

/* Purge and reset type-dependent state. */

1324

ieee80211_teardown_sdata(sdata);

1326

ieee80211_teardown_sdata(sdata);

1325

ieee80211_setup_sdata(sdata, type);

1327

ieee80211_setup_sdata(sdata, type);

1326

}

1328

}

1327

1329

1328

/* reset some values that shouldn't be kept across type changes */

1330

/* reset some values that shouldn't be kept across type changes */

1329

sdata->drop_unencrypted = 0;

1331

sdata->drop_unencrypted = 0;

1330

if (type == NL80211_IFTYPE_STATION)

1332

if (type == NL80211_IFTYPE_STATION)

1331

sdata->u.mgd.use_4addr = false;

1333

sdata->u.mgd.use_4addr = false;

1332

1334

1333

return 0;

1335

return 0;

1334

}

1336

}

1335

1337

1336

static void ieee80211_assign_perm_addr(struct ieee80211_local *local,

1338

static void ieee80211_assign_perm_addr(struct ieee80211_local *local,

1337

u8 *perm_addr, enum nl80211_iftype type)

1339

u8 *perm_addr, enum nl80211_iftype type)

1338

{

1340

{

1339

struct ieee80211_sub_if_data *sdata;

1341

struct ieee80211_sub_if_data *sdata;

1340

u64 mask, start, addr, val, inc;

1342

u64 mask, start, addr, val, inc;

1341

u8 *m;

1343

u8 *m;

1342

u8 tmp_addr[ETH_ALEN];

1344

u8 tmp_addr[ETH_ALEN];

1343

int i;

1345

int i;

1344

1346

1345

/* default ... something at least */

1347

/* default ... something at least */

1346

memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);

1348

memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);

1347

1349

1348

if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&

1350

if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&

1349

local->hw.wiphy->n_addresses <= 1)

1351

local->hw.wiphy->n_addresses <= 1)

1350

return;

1352

return;

1351

1353

1352

mutex_lock(&local->iflist_mtx);

1354

mutex_lock(&local->iflist_mtx);

1353

1355

1354

switch (type) {

1356

switch (type) {

1355

case NL80211_IFTYPE_MONITOR:

1357

case NL80211_IFTYPE_MONITOR:

1356

/* doesn't matter */

1358

/* doesn't matter */

1357

break;

1359

break;

1358

case NL80211_IFTYPE_WDS:

1360

case NL80211_IFTYPE_WDS:

1359

case NL80211_IFTYPE_AP_VLAN:

1361

case NL80211_IFTYPE_AP_VLAN:

1360

/* match up with an AP interface */

1362

/* match up with an AP interface */

1361

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

1363

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

1362

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

1364

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

1363

continue;

1365

continue;

1364

memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);

1366

memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);

1365

break;

1367

break;

1366

}

1368

}

1367

/* keep default if no AP interface present */

1369

/* keep default if no AP interface present */

1368

break;

1370

break;

1369

case NL80211_IFTYPE_P2P_CLIENT:

1371

case NL80211_IFTYPE_P2P_CLIENT:

1370

case NL80211_IFTYPE_P2P_GO:

1372

case NL80211_IFTYPE_P2P_GO:

1371

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

1373

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

1372

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

1374

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

1373

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

1375

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

1374

continue;

1376

continue;

1375

if (!ieee80211_sdata_running(sdata))

1377

if (!ieee80211_sdata_running(sdata))

1376

continue;

1378

continue;

1377

memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);

1379

memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);

1378

goto out_unlock;

1380

goto out_unlock;

1379

}

1381

}

1380

}

1382

}

1381

/* otherwise fall through */

1383

/* otherwise fall through */

1382

default:

1384

default:

1383

/* assign a new address if possible -- try n_addresses first */

1385

/* assign a new address if possible -- try n_addresses first */

1384

for (i = 0; i < local->hw.wiphy->n_addresses; i++) {

1386

for (i = 0; i < local->hw.wiphy->n_addresses; i++) {

1385

bool used = false;

1387

bool used = false;

1386

1388

1387

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

1389

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

1388

if (memcmp(local->hw.wiphy->addresses[i].addr,

1390

if (memcmp(local->hw.wiphy->addresses[i].addr,

1389

sdata->vif.addr, ETH_ALEN) == 0) {

1391

sdata->vif.addr, ETH_ALEN) == 0) {

1390

used = true;

1392

used = true;

1391

break;

1393

break;

1392

}

1394

}

1393

}

1395

}

1394

1396

1395

if (!used) {

1397

if (!used) {

1396

memcpy(perm_addr,

1398

memcpy(perm_addr,

1397

local->hw.wiphy->addresses[i].addr,

1399

local->hw.wiphy->addresses[i].addr,

1398

ETH_ALEN);

1400

ETH_ALEN);

1399

break;

1401

break;

1400

}

1402

}

1401

}

1403

}

1402

1404

1403

/* try mask if available */

1405

/* try mask if available */

1404

if (is_zero_ether_addr(local->hw.wiphy->addr_mask))

1406

if (is_zero_ether_addr(local->hw.wiphy->addr_mask))

1405

break;

1407

break;

1406

1408

1407

m = local->hw.wiphy->addr_mask;

1409

m = local->hw.wiphy->addr_mask;

1408

mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1410

mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1409

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1411

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1410

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1412

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1411

1413

1412

if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {

1414

if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {

1413

/* not a contiguous mask ... not handled now! */

1415

/* not a contiguous mask ... not handled now! */

1414

pr_info("not contiguous\n");

1416

pr_info("not contiguous\n");

1415

break;

1417

break;

1416

}

1418

}

1417

1419

1418

m = local->hw.wiphy->perm_addr;

1420

m = local->hw.wiphy->perm_addr;

1419

start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1421

start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1420

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1422

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1421

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1423

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1422

1424

1423

inc = 1ULL<<__ffs64(mask);

1425

inc = 1ULL<<__ffs64(mask);

1424

val = (start & mask);

1426

val = (start & mask);

1425

addr = (start & ~mask) | (val & mask);

1427

addr = (start & ~mask) | (val & mask);

1426

do {

1428

do {

1427

bool used = false;

1429

bool used = false;

1428

1430

1429

tmp_addr[5] = addr >> 0*8;

1431

tmp_addr[5] = addr >> 0*8;

1430

tmp_addr[4] = addr >> 1*8;

1432

tmp_addr[4] = addr >> 1*8;

1431

tmp_addr[3] = addr >> 2*8;

1433

tmp_addr[3] = addr >> 2*8;

1432

tmp_addr[2] = addr >> 3*8;

1434

tmp_addr[2] = addr >> 3*8;

1433

tmp_addr[1] = addr >> 4*8;

1435

tmp_addr[1] = addr >> 4*8;

1434

tmp_addr[0] = addr >> 5*8;

1436

tmp_addr[0] = addr >> 5*8;

1435

1437

1436

val += inc;

1438

val += inc;

1437

1439

1438

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

1440

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

1439

if (memcmp(tmp_addr, sdata->vif.addr,

1441

if (memcmp(tmp_addr, sdata->vif.addr,

1440

ETH_ALEN) == 0) {

1442

ETH_ALEN) == 0) {

1441

used = true;

1443

used = true;

1442

break;

1444

break;

1443

}

1445

}

1444

}

1446

}

1445

1447

1446

if (!used) {

1448

if (!used) {

1447

memcpy(perm_addr, tmp_addr, ETH_ALEN);

1449

memcpy(perm_addr, tmp_addr, ETH_ALEN);

1448

break;

1450

break;

1449

}

1451

}

1450

addr = (start & ~mask) | (val & mask);

1452

addr = (start & ~mask) | (val & mask);

1451

} while (addr != start);

1453

} while (addr != start);

1452

1454

1453

break;

1455

break;

1454

}

1456

}

1455

1457

1456

out_unlock:

1458

out_unlock:

1457

mutex_unlock(&local->iflist_mtx);

1459

mutex_unlock(&local->iflist_mtx);

1458

}

1460

}

1459

1461

1460

static void ieee80211_cleanup_sdata_stas_wk(struct work_struct *wk)

1462

static void ieee80211_cleanup_sdata_stas_wk(struct work_struct *wk)

1461

{

1463

{

1462

struct ieee80211_sub_if_data *sdata;

1464

struct ieee80211_sub_if_data *sdata;

1463

1465

1464

sdata = container_of(wk, struct ieee80211_sub_if_data, cleanup_stations_wk);

1466

sdata = container_of(wk, struct ieee80211_sub_if_data, cleanup_stations_wk);

1465

1467

1466

ieee80211_cleanup_sdata_stas(sdata);

1468

ieee80211_cleanup_sdata_stas(sdata);

1467

}

1469

}

1468

1470

1469

int ieee80211_if_add(struct ieee80211_local *local, const char *name,

1471

int ieee80211_if_add(struct ieee80211_local *local, const char *name,

1470

struct wireless_dev **new_wdev, enum nl80211_iftype type,

1472

struct wireless_dev **new_wdev, enum nl80211_iftype type,

1471

struct vif_params *params)

1473

struct vif_params *params)

1472

{

1474

{

1473

struct net_device *ndev = NULL;

1475

struct net_device *ndev = NULL;

1474

struct ieee80211_sub_if_data *sdata = NULL;

1476

struct ieee80211_sub_if_data *sdata = NULL;

1475

int ret, i;

1477

int ret, i;

1476

int txqs = 1;

1478

int txqs = 1;

1477

1479

1478

ASSERT_RTNL();

1480

ASSERT_RTNL();

1479

1481

1480

if (type == NL80211_IFTYPE_P2P_DEVICE) {

1482

if (type == NL80211_IFTYPE_P2P_DEVICE) {

1481

struct wireless_dev *wdev;

1483

struct wireless_dev *wdev;

1482

1484

1483

sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,

1485

sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,

1484

GFP_KERNEL);

1486

GFP_KERNEL);

1485

if (!sdata)

1487

if (!sdata)

1486

return -ENOMEM;

1488

return -ENOMEM;

1487

wdev = &sdata->wdev;

1489

wdev = &sdata->wdev;

1488

1490

1489

sdata->dev = NULL;

1491

sdata->dev = NULL;

1490

strlcpy(sdata->name, name, IFNAMSIZ);

1492

strlcpy(sdata->name, name, IFNAMSIZ);

1491

ieee80211_assign_perm_addr(local, wdev->address, type);

1493

ieee80211_assign_perm_addr(local, wdev->address, type);

1492

memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);

1494

memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);

1493

} else {

1495

} else {

1494

if (local->hw.queues >= IEEE80211_NUM_ACS)

1496

if (local->hw.queues >= IEEE80211_NUM_ACS)

1495

txqs = IEEE80211_NUM_ACS;

1497

txqs = IEEE80211_NUM_ACS;

1496

1498

1497

ndev = alloc_netdev_mqs(sizeof(*sdata) +

1499

ndev = alloc_netdev_mqs(sizeof(*sdata) +

1498

local->hw.vif_data_size,

1500

local->hw.vif_data_size,

1499

name, ieee80211_if_setup, txqs, 1);

1501

name, ieee80211_if_setup, txqs, 1);

1500

if (!ndev)

1502

if (!ndev)

1501

return -ENOMEM;

1503

return -ENOMEM;

1502

dev_net_set(ndev, wiphy_net(local->hw.wiphy));

1504

dev_net_set(ndev, wiphy_net(local->hw.wiphy));

1503

1505

1504

ndev->needed_headroom = local->tx_headroom +

1506

ndev->needed_headroom = local->tx_headroom +

1505

4*6 /* four MAC addresses */

1507

4*6 /* four MAC addresses */

1506

+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */

1508

+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */

1507

+ 6 /* mesh */

1509

+ 6 /* mesh */

1508

+ 8 /* rfc1042/bridge tunnel */

1510

+ 8 /* rfc1042/bridge tunnel */

1509

- ETH_HLEN /* ethernet hard_header_len */

1511

- ETH_HLEN /* ethernet hard_header_len */

1510

+ IEEE80211_ENCRYPT_HEADROOM;

1512

+ IEEE80211_ENCRYPT_HEADROOM;

1511

ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;

1513

ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;

1512

1514

1513

ret = dev_alloc_name(ndev, ndev->name);

1515

ret = dev_alloc_name(ndev, ndev->name);

1514

if (ret < 0) {

1516

if (ret < 0) {

1515

free_netdev(ndev);

1517

free_netdev(ndev);

1516

return ret;

1518

return ret;

1517

}

1519

}

1518

1520

1519

ieee80211_assign_perm_addr(local, ndev->perm_addr, type);

1521

ieee80211_assign_perm_addr(local, ndev->perm_addr, type);

1520

memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);

1522

memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);

1521

SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));

1523

SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));

1522

1524

1523

/* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */

1525

/* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */

1524

sdata = netdev_priv(ndev);

1526

sdata = netdev_priv(ndev);

1525

ndev->ieee80211_ptr = &sdata->wdev;

1527

ndev->ieee80211_ptr = &sdata->wdev;

1526

memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);

1528

memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);

1527

memcpy(sdata->name, ndev->name, IFNAMSIZ);

1529

memcpy(sdata->name, ndev->name, IFNAMSIZ);

1528

1530

1529

sdata->dev = ndev;

1531

sdata->dev = ndev;

1530

}

1532

}

1531

1533

1532

/* initialise type-independent data */

1534

/* initialise type-independent data */

1533

sdata->wdev.wiphy = local->hw.wiphy;

1535

sdata->wdev.wiphy = local->hw.wiphy;

1534

sdata->local = local;

1536

sdata->local = local;

1535

1537

1536

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

1538

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

1537

skb_queue_head_init(&sdata->fragments[i].skb_list);

1539

skb_queue_head_init(&sdata->fragments[i].skb_list);

1538

1540

1539

INIT_LIST_HEAD(&sdata->key_list);

1541

INIT_LIST_HEAD(&sdata->key_list);

1540

1542

1541

spin_lock_init(&sdata->cleanup_stations_lock);

1543

spin_lock_init(&sdata->cleanup_stations_lock);

1542

INIT_LIST_HEAD(&sdata->cleanup_stations);

1544

INIT_LIST_HEAD(&sdata->cleanup_stations);

1543

INIT_WORK(&sdata->cleanup_stations_wk, ieee80211_cleanup_sdata_stas_wk);

1545

INIT_WORK(&sdata->cleanup_stations_wk, ieee80211_cleanup_sdata_stas_wk);

1544

INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work,

1546

INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work,

1545

ieee80211_dfs_cac_timer_work);

1547

ieee80211_dfs_cac_timer_work);

1546

INIT_DELAYED_WORK(&sdata->dec_tailroom_needed_wk,

1548

INIT_DELAYED_WORK(&sdata->dec_tailroom_needed_wk,

1547

ieee80211_delayed_tailroom_dec);

1549

ieee80211_delayed_tailroom_dec);

1548

1550

1549

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

1551

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

1550

struct ieee80211_supported_band *sband;

1552

struct ieee80211_supported_band *sband;

1551

sband = local->hw.wiphy->bands[i];

1553

sband = local->hw.wiphy->bands[i];

1552

sdata->rc_rateidx_mask[i] =

1554

sdata->rc_rateidx_mask[i] =

1553

sband ? (1 << sband->n_bitrates) - 1 : 0;

1555

sband ? (1 << sband->n_bitrates) - 1 : 0;

1554

if (sband)

1556

if (sband)

1555

memcpy(sdata->rc_rateidx_mcs_mask[i],

1557

memcpy(sdata->rc_rateidx_mcs_mask[i],

1556

sband->ht_cap.mcs.rx_mask,

1558

sband->ht_cap.mcs.rx_mask,

1557

sizeof(sdata->rc_rateidx_mcs_mask[i]));

1559

sizeof(sdata->rc_rateidx_mcs_mask[i]));

1558

else

1560

else

1559

memset(sdata->rc_rateidx_mcs_mask[i], 0,

1561

memset(sdata->rc_rateidx_mcs_mask[i], 0,

1560

sizeof(sdata->rc_rateidx_mcs_mask[i]));

1562

sizeof(sdata->rc_rateidx_mcs_mask[i]));

1561

}

1563

}

1562

1564

1563

ieee80211_set_default_queues(sdata);

1565

ieee80211_set_default_queues(sdata);

1564

1566

1565

sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;

1567

sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;

1566

sdata->user_power_level = local->user_power_level;

1568

sdata->user_power_level = local->user_power_level;

1567

1569

1568

/* setup type-dependent data */

1570

/* setup type-dependent data */

1569

ieee80211_setup_sdata(sdata, type);

1571

ieee80211_setup_sdata(sdata, type);

1570

1572

1571

if (ndev) {

1573

if (ndev) {

1572

if (params) {

1574

if (params) {

1573

ndev->ieee80211_ptr->use_4addr = params->use_4addr;

1575

ndev->ieee80211_ptr->use_4addr = params->use_4addr;

1574

if (type == NL80211_IFTYPE_STATION)

1576

if (type == NL80211_IFTYPE_STATION)

1575

sdata->u.mgd.use_4addr = params->use_4addr;

1577

sdata->u.mgd.use_4addr = params->use_4addr;

1576

}

1578

}

1577

1579

1578

ndev->features |= local->hw.netdev_features;

1580

ndev->features |= local->hw.netdev_features;

1579

1581

1580

ret = register_netdevice(ndev);

1582

ret = register_netdevice(ndev);

1581

if (ret) {

1583

if (ret) {

1582

free_netdev(ndev);

1584

free_netdev(ndev);

1583

return ret;

1585

return ret;

1584

}

1586

}

1585

}

1587

}

1586

1588

1587

mutex_lock(&local->iflist_mtx);

1589

mutex_lock(&local->iflist_mtx);

1588

list_add_tail_rcu(&sdata->list, &local->interfaces);

1590

list_add_tail_rcu(&sdata->list, &local->interfaces);

1589

mutex_unlock(&local->iflist_mtx);

1591

mutex_unlock(&local->iflist_mtx);

1590

1592

1591

if (new_wdev)

1593

if (new_wdev)

1592

*new_wdev = &sdata->wdev;

1594

*new_wdev = &sdata->wdev;

1593

1595

1594

return 0;

1596

return 0;

1595

}

1597

}

1596

1598

1597

void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)

1599

void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)

1598

{

1600

{

1599

ASSERT_RTNL();

1601

ASSERT_RTNL();

1600

1602

1601

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

1603

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

1602

list_del_rcu(&sdata->list);

1604

list_del_rcu(&sdata->list);

1603

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

1605

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

1604

1606

1605

synchronize_rcu();

1607

synchronize_rcu();

1606

1608

1607

if (sdata->dev) {

1609

if (sdata->dev) {

1608

unregister_netdevice(sdata->dev);

1610

unregister_netdevice(sdata->dev);

1609

} else {

1611

} else {

1610

cfg80211_unregister_wdev(&sdata->wdev);

1612

cfg80211_unregister_wdev(&sdata->wdev);

1611

kfree(sdata);

1613

kfree(sdata);

1612

}

1614

}

1613

}

1615

}

1614

1616

1615

void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)

1617

void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)

1616

{

1618

{

1617

if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))

1619

if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))

1618

return;

1620

return;

1619

ieee80211_do_stop(sdata, true);

1621

ieee80211_do_stop(sdata, true);

1620

ieee80211_teardown_sdata(sdata);

1622

ieee80211_teardown_sdata(sdata);

1621

}

1623

}

1622

1624

1623

/*

1625

/*

1624

* Remove all interfaces, may only be called at hardware unregistration

1626

* Remove all interfaces, may only be called at hardware unregistration

1625

* time because it doesn't do RCU-safe list removals.

1627

* time because it doesn't do RCU-safe list removals.

1626

*/

1628

*/

1627

void ieee80211_remove_interfaces(struct ieee80211_local *local)

1629

void ieee80211_remove_interfaces(struct ieee80211_local *local)

1628

{

1630

{

1629

struct ieee80211_sub_if_data *sdata, *tmp;

1631

struct ieee80211_sub_if_data *sdata, *tmp;

1630

LIST_HEAD(unreg_list);

1632

LIST_HEAD(unreg_list);

1631

LIST_HEAD(wdev_list);

1633

LIST_HEAD(wdev_list);

1632

1634

1633

ASSERT_RTNL();

1635

ASSERT_RTNL();

1634

1636

1635

mutex_lock(&local->iflist_mtx);

1637

mutex_lock(&local->iflist_mtx);

1636

list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {

1638

list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {

1637

list_del(&sdata->list);

1639

list_del(&sdata->list);

1638

1640

1639

if (sdata->dev)

1641

if (sdata->dev)

1640

unregister_netdevice_queue(sdata->dev, &unreg_list);

1642

unregister_netdevice_queue(sdata->dev, &unreg_list);

1641

else

1643

else

1642

list_add(&sdata->list, &wdev_list);

1644

list_add(&sdata->list, &wdev_list);

1643

}

1645

}

1644

mutex_unlock(&local->iflist_mtx);

1646

mutex_unlock(&local->iflist_mtx);

1645

unregister_netdevice_many(&unreg_list);

1647

unregister_netdevice_many(&unreg_list);

1646

list_del(&unreg_list);

1648

list_del(&unreg_list);

1647

1649

1648

list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {

1650

list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {

1649

list_del(&sdata->list);

1651

list_del(&sdata->list);

1650

cfg80211_unregister_wdev(&sdata->wdev);

1652

cfg80211_unregister_wdev(&sdata->wdev);

1651

kfree(sdata);

1653

kfree(sdata);

1652

}

1654

}

1653

}

1655

}

1654

1656

1655

static int netdev_notify(struct notifier_block *nb,

1657

static int netdev_notify(struct notifier_block *nb,

1656

unsigned long state,

1658

unsigned long state,

1657

void *ndev)

1659

void *ndev)

1658

{

1660

{

1659

struct net_device *dev = ndev;

1661

struct net_device *dev = ndev;

1660

struct ieee80211_sub_if_data *sdata;

1662

struct ieee80211_sub_if_data *sdata;

1661

1663

1662

if (state != NETDEV_CHANGENAME)

1664

if (state != NETDEV_CHANGENAME)

1663

return 0;

1665

return 0;

1664

1666

1665

if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)

1667

if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)

1666

return 0;

1668

return 0;

1667

1669

1668

if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)

1670

if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)

1669

return 0;

1671

return 0;

1670

1672

1671

sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1673

sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1672

1674

1673

memcpy(sdata->name, dev->name, IFNAMSIZ);

1675

memcpy(sdata->name, dev->name, IFNAMSIZ);

1674

1676

1675

ieee80211_debugfs_rename_netdev(sdata);

1677

ieee80211_debugfs_rename_netdev(sdata);

1676

return 0;

1678

return 0;

1677

}

1679

}

1678

1680

1679

static struct notifier_block mac80211_netdev_notifier = {

1681

static struct notifier_block mac80211_netdev_notifier = {

1680

.notifier_call = netdev_notify,

1682

.notifier_call = netdev_notify,

1681

};

1683

};

1682

1684

1683

int ieee80211_iface_init(void)

1685

int ieee80211_iface_init(void)

1684

{

1686

{

1685

return register_netdevice_notifier(&mac80211_netdev_notifier);

1687

return register_netdevice_notifier(&mac80211_netdev_notifier);

1686

}

1688

}

1687

1689

1688

void ieee80211_iface_exit(void)

1690

void ieee80211_iface_exit(void)

1689

{

1691

{

1690

unregister_netdevice_notifier(&mac80211_netdev_notifier);

1692

unregister_netdevice_notifier(&mac80211_netdev_notifier);

GITLAB

mac80211: simplify AP interface stop

 /*
  * Interface handling (except master interface)
  *
  * Copyright 2002-2005, Instant802 Networks, Inc.
  * Copyright 2005-2006, Devicescape Software, Inc.
  * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
  * Copyright 2008, Johannes Berg <johannes@sipsolutions.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/slab.h>
 #include <linux/kernel.h>
 #include <linux/if_arp.h>
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
 #include <net/mac80211.h>
 #include <net/ieee80211_radiotap.h>
 #include "ieee80211_i.h"
 #include "sta_info.h"
 #include "debugfs_netdev.h"
 #include "mesh.h"
 #include "led.h"
 #include "driver-ops.h"
 #include "wme.h"
 #include "rate.h"
 /**
  * DOC: Interface list locking
  *
  * The interface list in each struct ieee80211_local is protected
  * three-fold:
  *
  * (1) modifications may only be done under the RTNL
  * (2) modifications and readers are protected against each other by
  *     the iflist_mtx.
  * (3) modifications are done in an RCU manner so atomic readers
  *     can traverse the list in RCU-safe blocks.
  *
  * As a consequence, reads (traversals) of the list can be protected
  * by either the RTNL, the iflist_mtx or RCU.
  */
 bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_chanctx_conf *chanctx_conf;
 	int power;
 	rcu_read_lock();
 	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
 	if (!chanctx_conf) {
 		rcu_read_unlock();
 		return false;
 	}
 	power = chanctx_conf->def.chan->max_power;
 	rcu_read_unlock();
 	if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)
 		power = min(power, sdata->user_power_level);
 	if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
 		power = min(power, sdata->ap_power_level);
 	if (power != sdata->vif.bss_conf.txpower) {
 		sdata->vif.bss_conf.txpower = power;
 		ieee80211_hw_config(sdata->local, 0);
 		return true;
 	}
 	return false;
 }
 void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
 {
 	if (__ieee80211_recalc_txpower(sdata))
 		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
 }
 static u32 ieee80211_idle_off(struct ieee80211_local *local)
 {
 	if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
 		return 0;
 	local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
 	return IEEE80211_CONF_CHANGE_IDLE;
 }
 static u32 ieee80211_idle_on(struct ieee80211_local *local)
 {
 	if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
 		return 0;
 	drv_flush(local, false);
 	local->hw.conf.flags |= IEEE80211_CONF_IDLE;
 	return IEEE80211_CONF_CHANGE_IDLE;
 }
 void ieee80211_recalc_idle(struct ieee80211_local *local)
 {
 	bool working = false, scanning, active;
 	unsigned int led_trig_start = 0, led_trig_stop = 0;
 	struct ieee80211_roc_work *roc;
 	u32 change;
 	lockdep_assert_held(&local->mtx);
 	active = !list_empty(&local->chanctx_list) || local->monitors;
 	if (!local->ops->remain_on_channel) {
 		list_for_each_entry(roc, &local->roc_list, list) {
 			working = true;
 			break;
 		}
 	}
 	scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
 		   test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
 	if (working || scanning)
 		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
 	else
 		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
 	if (active)
 		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
 	else
 		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
 	ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
 	if (working || scanning || active)
 		change = ieee80211_idle_off(local);
 	else
 		change = ieee80211_idle_on(local);
 	if (change)
 		ieee80211_hw_config(local, change);
 }
 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
 {
 	if (new_mtu < 256 || new_mtu > IEEE80211_MAX_DATA_LEN)
 		return -EINVAL;
 	dev->mtu = new_mtu;
 	return 0;
 }
 static int ieee80211_verify_mac(struct ieee80211_local *local, u8 *addr)
 {
 	struct ieee80211_sub_if_data *sdata;
 	u64 new, mask, tmp;
 	u8 *m;
 	int ret = 0;
 	if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
 		return 0;
 	m = addr;
 	new =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
 		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
 		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
 	m = local->hw.wiphy->addr_mask;
 	mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
 		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
 		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
 	mutex_lock(&local->iflist_mtx);
 	list_for_each_entry(sdata, &local->interfaces, list) {
 		if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
 			continue;
 		m = sdata->vif.addr;
 		tmp =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
 		if ((new & ~mask) != (tmp & ~mask)) {
 			ret = -EINVAL;
 			break;
 		}
 	}
 	mutex_unlock(&local->iflist_mtx);
 	return ret;
 }
 static int ieee80211_change_mac(struct net_device *dev, void *addr)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct sockaddr *sa = addr;
 	int ret;
 	if (ieee80211_sdata_running(sdata))
 		return -EBUSY;
 	ret = ieee80211_verify_mac(sdata->local, sa->sa_data);
 	if (ret)
 		return ret;
 	ret = eth_mac_addr(dev, sa);
 	if (ret == 0)
 		memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
 	return ret;
 }
 static inline int identical_mac_addr_allowed(int type1, int type2)
 {
 	return type1 == NL80211_IFTYPE_MONITOR ||
 		type2 == NL80211_IFTYPE_MONITOR ||
 		type1 == NL80211_IFTYPE_P2P_DEVICE ||
 		type2 == NL80211_IFTYPE_P2P_DEVICE ||
 		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
 		(type1 == NL80211_IFTYPE_WDS &&
 			(type2 == NL80211_IFTYPE_WDS ||
 			 type2 == NL80211_IFTYPE_AP)) ||
 		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
 		(type1 == NL80211_IFTYPE_AP_VLAN &&
 			(type2 == NL80211_IFTYPE_AP ||
 			 type2 == NL80211_IFTYPE_AP_VLAN));
 }
 static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
 					    enum nl80211_iftype iftype)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_sub_if_data *nsdata;
 	ASSERT_RTNL();
 	/* we hold the RTNL here so can safely walk the list */
 	list_for_each_entry(nsdata, &local->interfaces, list) {
 		if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
 			/*
 			 * Allow only a single IBSS interface to be up at any
 			 * time. This is restricted because beacon distribution
 			 * cannot work properly if both are in the same IBSS.
 			 *
 			 * To remove this restriction we'd have to disallow them
 			 * from setting the same SSID on different IBSS interfaces
 			 * belonging to the same hardware. Then, however, we're
 			 * faced with having to adopt two different TSF timers...
 			 */
 			if (iftype == NL80211_IFTYPE_ADHOC &&
 			    nsdata->vif.type == NL80211_IFTYPE_ADHOC)
 				return -EBUSY;
 			/*
 			 * The remaining checks are only performed for interfaces
 			 * with the same MAC address.
 			 */
 			if (!ether_addr_equal(sdata->vif.addr,
 					      nsdata->vif.addr))
 				continue;
 			/*
 			 * check whether it may have the same address
 			 */
 			if (!identical_mac_addr_allowed(iftype,
 							nsdata->vif.type))
 				return -ENOTUNIQ;
 			/*
 			 * can only add VLANs to enabled APs
 			 */
 			if (iftype == NL80211_IFTYPE_AP_VLAN &&
 			    nsdata->vif.type == NL80211_IFTYPE_AP)
 				sdata->bss = &nsdata->u.ap;
 		}
 	}
 	return 0;
 }
 static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata)
 {
 	int n_queues = sdata->local->hw.queues;
 	int i;
 	if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
 		for (i = 0; i < IEEE80211_NUM_ACS; i++) {
 			if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==
 					 IEEE80211_INVAL_HW_QUEUE))
 				return -EINVAL;
 			if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=
 					 n_queues))
 				return -EINVAL;
 		}
 	}
 	if ((sdata->vif.type != NL80211_IFTYPE_AP &&
 	     sdata->vif.type != NL80211_IFTYPE_MESH_POINT) ||
 	    !(sdata->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) {
 		sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
 		return 0;
 	}
 	if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))
 		return -EINVAL;
 	if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))
 		return -EINVAL;
 	return 0;
 }
 void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
 				    const int offset)
 {
 	struct ieee80211_local *local = sdata->local;
 	u32 flags = sdata->u.mntr_flags;
 #define ADJUST(_f, _s)	do {					\
 	if (flags & MONITOR_FLAG_##_f)				\
 		local->fif_##_s += offset;			\
 	} while (0)
 	ADJUST(FCSFAIL, fcsfail);
 	ADJUST(PLCPFAIL, plcpfail);
 	ADJUST(CONTROL, control);
 	ADJUST(CONTROL, pspoll);
 	ADJUST(OTHER_BSS, other_bss);
 #undef ADJUST
 }
 static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_local *local = sdata->local;
 	int i;
 	for (i = 0; i < IEEE80211_NUM_ACS; i++) {
 		if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
 			sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
 		else if (local->hw.queues >= IEEE80211_NUM_ACS)
 			sdata->vif.hw_queue[i] = i;
 		else
 			sdata->vif.hw_queue[i] = 0;
 	}
 	sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
 }
 static int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
 {
 	struct ieee80211_sub_if_data *sdata;
 	int ret = 0;
 	if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
 		return 0;
 	mutex_lock(&local->iflist_mtx);
 	if (local->monitor_sdata)
 		goto out_unlock;
 	sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
 	if (!sdata) {
 		ret = -ENOMEM;
 		goto out_unlock;
 	}
 	/* set up data */
 	sdata->local = local;
 	sdata->vif.type = NL80211_IFTYPE_MONITOR;
 	snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
 		 wiphy_name(local->hw.wiphy));
 	ieee80211_set_default_queues(sdata);
 	ret = drv_add_interface(local, sdata);
 	if (WARN_ON(ret)) {
 		/* ok .. stupid driver, it asked for this! */
 		kfree(sdata);
 		goto out_unlock;
 	}
 	ret = ieee80211_check_queues(sdata);
 	if (ret) {
 		kfree(sdata);
 		goto out_unlock;
 	}
 	ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,
 					IEEE80211_CHANCTX_EXCLUSIVE);
 	if (ret) {
 		drv_remove_interface(local, sdata);
 		kfree(sdata);
 		goto out_unlock;
 	}
 	rcu_assign_pointer(local->monitor_sdata, sdata);
  out_unlock:
 	mutex_unlock(&local->iflist_mtx);
 	return ret;
 }
 static void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
 {
 	struct ieee80211_sub_if_data *sdata;
 	if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
 		return;
 	mutex_lock(&local->iflist_mtx);
 	sdata = rcu_dereference_protected(local->monitor_sdata,
 					  lockdep_is_held(&local->iflist_mtx));
 	if (!sdata)
 		goto out_unlock;
 	rcu_assign_pointer(local->monitor_sdata, NULL);
 	synchronize_net();
 	ieee80211_vif_release_channel(sdata);
 	drv_remove_interface(local, sdata);
 	kfree(sdata);
  out_unlock:
 	mutex_unlock(&local->iflist_mtx);
 }
 /*
  * NOTE: Be very careful when changing this function, it must NOT return
  * an error on interface type changes that have been pre-checked, so most
  * checks should be in ieee80211_check_concurrent_iface.
  */
 int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 	struct net_device *dev = wdev->netdev;
 	struct ieee80211_local *local = sdata->local;
 	struct sta_info *sta;
 	u32 changed = 0;
 	int res;
 	u32 hw_reconf_flags = 0;
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_WDS:
 		if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
 			return -ENOLINK;
 		break;
 	case NL80211_IFTYPE_AP_VLAN: {
 		struct ieee80211_sub_if_data *master;
 		if (!sdata->bss)
 			return -ENOLINK;
 		list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
 		master = container_of(sdata->bss,
 				      struct ieee80211_sub_if_data, u.ap);
 		sdata->control_port_protocol =
 			master->control_port_protocol;
 		sdata->control_port_no_encrypt =
 			master->control_port_no_encrypt;
 		break;
 		}
 	case NL80211_IFTYPE_AP:
 		sdata->bss = &sdata->u.ap;
 		break;
 	case NL80211_IFTYPE_MESH_POINT:
 	case NL80211_IFTYPE_STATION:
 	case NL80211_IFTYPE_MONITOR:
 	case NL80211_IFTYPE_ADHOC:
 	case NL80211_IFTYPE_P2P_DEVICE:
 		/* no special treatment */
 		break;
 	case NL80211_IFTYPE_UNSPECIFIED:
 	case NUM_NL80211_IFTYPES:
 	case NL80211_IFTYPE_P2P_CLIENT:
 	case NL80211_IFTYPE_P2P_GO:
 		/* cannot happen */
 		WARN_ON(1);
 		break;
 	}
 	if (local->open_count == 0) {
 		res = drv_start(local);
 		if (res)
 			goto err_del_bss;
 		/* we're brought up, everything changes */
 		hw_reconf_flags = ~0;
 		ieee80211_led_radio(local, true);
 		ieee80211_mod_tpt_led_trig(local,
 					   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
 	}
 	/*
 	 * Copy the hopefully now-present MAC address to
 	 * this interface, if it has the special null one.
 	 */
 	if (dev && is_zero_ether_addr(dev->dev_addr)) {
 		memcpy(dev->dev_addr,
 		       local->hw.wiphy->perm_addr,
 		       ETH_ALEN);
 		memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
 		if (!is_valid_ether_addr(dev->dev_addr)) {
 			res = -EADDRNOTAVAIL;
 			goto err_stop;
 		}
 	}
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_AP_VLAN:
 		/* no need to tell driver, but set carrier and chanctx */
 		if (rtnl_dereference(sdata->bss->beacon)) {
 			ieee80211_vif_vlan_copy_chanctx(sdata);
 			netif_carrier_on(dev);
 		} else {
 			netif_carrier_off(dev);
 		}
 		break;
 	case NL80211_IFTYPE_MONITOR:
 		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
 			local->cooked_mntrs++;
 			break;
 		}
 		if (local->monitors == 0 && local->open_count == 0) {
 			res = ieee80211_add_virtual_monitor(local);
 			if (res)
 				goto err_stop;
 		}
 		/* must be before the call to ieee80211_configure_filter */
 		local->monitors++;
 		if (local->monitors == 1) {
 			local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
 			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
 		}
 		ieee80211_adjust_monitor_flags(sdata, 1);
 		ieee80211_configure_filter(local);
 		mutex_lock(&local->mtx);
 		ieee80211_recalc_idle(local);
 		mutex_unlock(&local->mtx);
 		netif_carrier_on(dev);
 		break;
 	default:
 		if (coming_up) {
 			ieee80211_del_virtual_monitor(local);
 			res = drv_add_interface(local, sdata);
 			if (res)
 				goto err_stop;
 			res = ieee80211_check_queues(sdata);
 			if (res)
 				goto err_del_interface;
 		}
 		drv_add_interface_debugfs(local, sdata);
 		if (sdata->vif.type == NL80211_IFTYPE_AP) {
 			local->fif_pspoll++;
 			local->fif_probe_req++;
 			ieee80211_configure_filter(local);
 		} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
 			local->fif_probe_req++;
 		}
 		if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
 			changed |= ieee80211_reset_erp_info(sdata);
 		ieee80211_bss_info_change_notify(sdata, changed);
 		switch (sdata->vif.type) {
 		case NL80211_IFTYPE_STATION:
 		case NL80211_IFTYPE_ADHOC:
 		case NL80211_IFTYPE_AP:
 		case NL80211_IFTYPE_MESH_POINT:
 			netif_carrier_off(dev);
 			break;
 		case NL80211_IFTYPE_WDS:
 		case NL80211_IFTYPE_P2P_DEVICE:
 			break;
 		default:
 			netif_carrier_on(dev);
 		}
 		/*
 		 * set default queue parameters so drivers don't
 		 * need to initialise the hardware if the hardware
 		 * doesn't start up with sane defaults
 		 */
 		ieee80211_set_wmm_default(sdata, true);
 	}
 	set_bit(SDATA_STATE_RUNNING, &sdata->state);
 	if (sdata->vif.type == NL80211_IFTYPE_WDS) {
 		/* Create STA entry for the WDS peer */
 		sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
 				     GFP_KERNEL);
 		if (!sta) {
 			res = -ENOMEM;
 			goto err_del_interface;
 		}
 		sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
 		sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
 		sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
 		res = sta_info_insert(sta);
 		if (res) {
 			/* STA has been freed */
 			goto err_del_interface;
 		}
 		rate_control_rate_init(sta);
 		netif_carrier_on(dev);
 	} else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
 		rcu_assign_pointer(local->p2p_sdata, sdata);
 	}
 	/*
 	 * set_multicast_list will be invoked by the networking core
 	 * which will check whether any increments here were done in
 	 * error and sync them down to the hardware as filter flags.
 	 */
 	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
 		atomic_inc(&local->iff_allmultis);
 	if (sdata->flags & IEEE80211_SDATA_PROMISC)
 		atomic_inc(&local->iff_promiscs);
 	if (coming_up)
 		local->open_count++;
 	if (hw_reconf_flags)
 		ieee80211_hw_config(local, hw_reconf_flags);
 	ieee80211_recalc_ps(local, -1);
 	if (dev)
 		netif_tx_start_all_queues(dev);
 	return 0;
  err_del_interface:
 	drv_remove_interface(local, sdata);
  err_stop:
 	if (!local->open_count)
 		drv_stop(local);
  err_del_bss:
 	sdata->bss = NULL;
 	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 		list_del(&sdata->u.vlan.list);
 	/* might already be clear but that doesn't matter */
 	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
 	return res;
 }
 static int ieee80211_open(struct net_device *dev)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	int err;
 	/* fail early if user set an invalid address */
 	if (!is_valid_ether_addr(dev->dev_addr))
 		return -EADDRNOTAVAIL;
 	err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
 	if (err)
 		return err;
 	return ieee80211_do_open(&sdata->wdev, true);
 }
 static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
 			      bool going_down)
 {
 	struct ieee80211_local *local = sdata->local;
 	unsigned long flags;
 	struct sk_buff *skb, *tmp;
 	u32 hw_reconf_flags = 0;
 	int i, flushed;
 	struct ps_data *ps;
 	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
 	if (rcu_access_pointer(local->scan_sdata) == sdata)
 		ieee80211_scan_cancel(local);
 	/*
 	 * Stop TX on this interface first.
 	 */
 	if (sdata->dev)
 		netif_tx_stop_all_queues(sdata->dev);
 	ieee80211_roc_purge(sdata);
 	if (sdata->vif.type == NL80211_IFTYPE_STATION)
 		ieee80211_mgd_stop(sdata);
 	/*
 	 * Remove all stations associated with this interface.
 	 *
 	 * This must be done before calling ops->remove_interface()
 	 * because otherwise we can later invoke ops->sta_notify()
 	 * whenever the STAs are removed, and that invalidates driver
 	 * assumptions about always getting a vif pointer that is valid
 	 * (because if we remove a STA after ops->remove_interface()
 	 * the driver will have removed the vif info already!)
 	 *
 	 * This is relevant only in WDS mode, in all other modes we've
 	 * already removed all stations when disconnecting or similar,
 	 * so warn otherwise.
 	 *
 	 * We call sta_info_flush_cleanup() later, to combine RCU waits.
 	 */
 	flushed = sta_info_flush_defer(sdata);
 	WARN_ON_ONCE((sdata->vif.type != NL80211_IFTYPE_WDS && flushed > 0) ||
 		     (sdata->vif.type == NL80211_IFTYPE_WDS && flushed != 1));
 	/*
 	 * Don't count this interface for promisc/allmulti while it
 	 * is down. dev_mc_unsync() will invoke set_multicast_list
 	 * on the master interface which will sync these down to the
 	 * hardware as filter flags.
 	 */
 	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
 		atomic_dec(&local->iff_allmultis);
 	if (sdata->flags & IEEE80211_SDATA_PROMISC)
 		atomic_dec(&local->iff_promiscs);
 	if (sdata->vif.type == NL80211_IFTYPE_AP) {
 		local->fif_pspoll--;
 		local->fif_probe_req--;
 	} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
 		local->fif_probe_req--;
 	}
 	if (sdata->dev) {
 		netif_addr_lock_bh(sdata->dev);
 		spin_lock_bh(&local->filter_lock);
 		__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
 				 sdata->dev->addr_len);
 		spin_unlock_bh(&local->filter_lock);
 		netif_addr_unlock_bh(sdata->dev);
 		ieee80211_configure_filter(local);
 	}
 	del_timer_sync(&local->dynamic_ps_timer);
 	cancel_work_sync(&local->dynamic_ps_enable_work);
 	cancel_work_sync(&sdata->recalc_smps);
 	cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
 	if (sdata->wdev.cac_started) {
 		mutex_lock(&local->iflist_mtx);
 		ieee80211_vif_release_channel(sdata);
 		mutex_unlock(&local->iflist_mtx);
 		cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,
 				   GFP_KERNEL);
 	}
 	/* APs need special treatment */
 	if (sdata->vif.type == NL80211_IFTYPE_AP) {
 		struct ieee80211_sub_if_data *vlan, *tmpsdata;
 		/* down all dependent devices, that is VLANs */
 		list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
 					 u.vlan.list)
 			dev_close(vlan->dev);
 		WARN_ON(!list_empty(&sdata->u.ap.vlans));
 	} else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
 		/* remove all packets in parent bc_buf pointing to this dev */
 		ps = &sdata->bss->ps;
 		spin_lock_irqsave(&ps->bc_buf.lock, flags);
 		skb_queue_walk_safe(&ps->bc_buf, skb, tmp) {
 			if (skb->dev == sdata->dev) {
 				__skb_unlink(skb, &ps->bc_buf);
 				local->total_ps_buffered--;
 				ieee80211_free_txskb(&local->hw, skb);
 			}
 		}
 		spin_unlock_irqrestore(&ps->bc_buf.lock, flags);
 	}
 	if (going_down)
 		local->open_count--;
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_AP_VLAN:
 		list_del(&sdata->u.vlan.list);
 		rcu_assign_pointer(sdata->vif.chanctx_conf, NULL);
 		/* no need to tell driver */
 		break;
 	case NL80211_IFTYPE_MONITOR:
 		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
 			local->cooked_mntrs--;
 			break;
 		}
 		local->monitors--;
 		if (local->monitors == 0) {
 			local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
 			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
 			ieee80211_del_virtual_monitor(local);
 		}
 		ieee80211_adjust_monitor_flags(sdata, -1);
 		ieee80211_configure_filter(local);
 		mutex_lock(&local->mtx);
 		ieee80211_recalc_idle(local);
 		mutex_unlock(&local->mtx);
 		break;
 	case NL80211_IFTYPE_P2P_DEVICE:
 		/* relies on synchronize_rcu() below */
 		rcu_assign_pointer(local->p2p_sdata, NULL);
 		/* fall through */
 	default:
 		cancel_work_sync(&sdata->work);
 		/*
 		 * When we get here, the interface is marked down.
 		 *
 		 * sta_info_flush_cleanup() requires rcu_barrier()
 		 * first to wait for the station call_rcu() calls
 		 * to complete, here we need at least sychronize_rcu()
 		 * it to wait for the RX path in case it is using the
 		 * interface and enqueuing frames at this very time on
 		 * another CPU.
 		 */
 		rcu_barrier();
 		sta_info_flush_cleanup(sdata);
-		skb_queue_purge(&sdata->skb_queue);
 		/*
 		 * Free all remaining keys, there shouldn't be any,
 		 * except maybe in WDS mode?
 		 */
 		ieee80211_free_keys(sdata);
+		/* fall through */
+	case NL80211_IFTYPE_AP:
+		skb_queue_purge(&sdata->skb_queue);
 		drv_remove_interface_debugfs(local, sdata);
 		if (going_down)
 			drv_remove_interface(local, sdata);
 	}
 	sdata->bss = NULL;
 	ieee80211_recalc_ps(local, -1);
 	if (local->open_count == 0) {
 		ieee80211_clear_tx_pending(local);
 		ieee80211_stop_device(local);
 		/* no reconfiguring after stop! */
 		hw_reconf_flags = 0;
 	}
 	/* do after stop to avoid reconfiguring when we stop anyway */
 	if (hw_reconf_flags)
 		ieee80211_hw_config(local, hw_reconf_flags);
 	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 	for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
 		skb_queue_walk_safe(&local->pending[i], skb, tmp) {
 			struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 			if (info->control.vif == &sdata->vif) {
 				__skb_unlink(skb, &local->pending[i]);
 				ieee80211_free_txskb(&local->hw, skb);
 			}
 		}
 	}
 	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 	if (local->monitors == local->open_count && local->monitors > 0)
 		ieee80211_add_virtual_monitor(local);
 }
 static int ieee80211_stop(struct net_device *dev)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	ieee80211_do_stop(sdata, true);
 	return 0;
 }
 static void ieee80211_set_multicast_list(struct net_device *dev)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct ieee80211_local *local = sdata->local;
 	int allmulti, promisc, sdata_allmulti, sdata_promisc;
 	allmulti = !!(dev->flags & IFF_ALLMULTI);
 	promisc = !!(dev->flags & IFF_PROMISC);
 	sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
 	sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
 	if (allmulti != sdata_allmulti) {
 		if (dev->flags & IFF_ALLMULTI)
 			atomic_inc(&local->iff_allmultis);
 		else
 			atomic_dec(&local->iff_allmultis);
 		sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
 	}
 	if (promisc != sdata_promisc) {
 		if (dev->flags & IFF_PROMISC)
 			atomic_inc(&local->iff_promiscs);
 		else
 			atomic_dec(&local->iff_promiscs);
 		sdata->flags ^= IEEE80211_SDATA_PROMISC;
 	}
 	spin_lock_bh(&local->filter_lock);
 	__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
 	spin_unlock_bh(&local->filter_lock);
 	ieee80211_queue_work(&local->hw, &local->reconfig_filter);
 }
 /*
  * Called when the netdev is removed or, by the code below, before
  * the interface type changes.
  */
 static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
 {
 	int flushed;
 	int i;
 	/* free extra data */
 	ieee80211_free_keys(sdata);
 	ieee80211_debugfs_remove_netdev(sdata);
 	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
 		__skb_queue_purge(&sdata->fragments[i].skb_list);
 	sdata->fragment_next = 0;
 	if (ieee80211_vif_is_mesh(&sdata->vif))
 		mesh_rmc_free(sdata);
 	flushed = sta_info_flush(sdata);
 	WARN_ON(flushed);
 }
 static void ieee80211_uninit(struct net_device *dev)
 {
 	ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
 }
 static u16 ieee80211_netdev_select_queue(struct net_device *dev,
 					 struct sk_buff *skb)
 {
 	return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
 }
 static const struct net_device_ops ieee80211_dataif_ops = {
 	.ndo_open		= ieee80211_open,
 	.ndo_stop		= ieee80211_stop,
 	.ndo_uninit		= ieee80211_uninit,
 	.ndo_start_xmit		= ieee80211_subif_start_xmit,
 	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
 	.ndo_change_mtu 	= ieee80211_change_mtu,
 	.ndo_set_mac_address 	= ieee80211_change_mac,
 	.ndo_select_queue	= ieee80211_netdev_select_queue,
 };
 static u16 ieee80211_monitor_select_queue(struct net_device *dev,
 					  struct sk_buff *skb)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_hdr *hdr;
 	struct ieee80211_radiotap_header *rtap = (void *)skb->data;
 	if (local->hw.queues < IEEE80211_NUM_ACS)
 		return 0;
 	if (skb->len < 4 ||
 	    skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
 		return 0; /* doesn't matter, frame will be dropped */
 	hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
 	return ieee80211_select_queue_80211(sdata, skb, hdr);
 }
 static const struct net_device_ops ieee80211_monitorif_ops = {
 	.ndo_open		= ieee80211_open,
 	.ndo_stop		= ieee80211_stop,
 	.ndo_uninit		= ieee80211_uninit,
 	.ndo_start_xmit		= ieee80211_monitor_start_xmit,
 	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
 	.ndo_change_mtu 	= ieee80211_change_mtu,
 	.ndo_set_mac_address 	= eth_mac_addr,
 	.ndo_select_queue	= ieee80211_monitor_select_queue,
 };
 static void ieee80211_if_setup(struct net_device *dev)
 {
 	ether_setup(dev);
 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 	dev->netdev_ops = &ieee80211_dataif_ops;
 	dev->destructor = free_netdev;
 }
 static void ieee80211_iface_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data, work);
 	struct ieee80211_local *local = sdata->local;
 	struct sk_buff *skb;
 	struct sta_info *sta;
 	struct ieee80211_ra_tid *ra_tid;
 	if (!ieee80211_sdata_running(sdata))
 		return;
 	if (local->scanning)
 		return;
 	/*
 	 * ieee80211_queue_work() should have picked up most cases,
 	 * here we'll pick the rest.
 	 */
 	if (WARN(local->suspended,
 		 "interface work scheduled while going to suspend\n"))
 		return;
 	/* first process frames */
 	while ((skb = skb_dequeue(&sdata->skb_queue))) {
 		struct ieee80211_mgmt *mgmt = (void *)skb->data;
 		if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {
 			ra_tid = (void *)&skb->cb;
 			ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,
 						 ra_tid->tid);
 		} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {
 			ra_tid = (void *)&skb->cb;
 			ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,
 						ra_tid->tid);
 		} else if (ieee80211_is_action(mgmt->frame_control) &&
 			   mgmt->u.action.category == WLAN_CATEGORY_BACK) {
 			int len = skb->len;
 			mutex_lock(&local->sta_mtx);
 			sta = sta_info_get_bss(sdata, mgmt->sa);
 			if (sta) {
 				switch (mgmt->u.action.u.addba_req.action_code) {
 				case WLAN_ACTION_ADDBA_REQ:
 					ieee80211_process_addba_request(
 							local, sta, mgmt, len);
 					break;
 				case WLAN_ACTION_ADDBA_RESP:
 					ieee80211_process_addba_resp(local, sta,
 								     mgmt, len);
 					break;
 				case WLAN_ACTION_DELBA:
 					ieee80211_process_delba(sdata, sta,
 								mgmt, len);
 					break;
 				default:
 					WARN_ON(1);
 					break;
 				}
 			}
 			mutex_unlock(&local->sta_mtx);
 		} else if (ieee80211_is_data_qos(mgmt->frame_control)) {
 			struct ieee80211_hdr *hdr = (void *)mgmt;
 			/*
 			 * So the frame isn't mgmt, but frame_control
 			 * is at the right place anyway, of course, so
 			 * the if statement is correct.
 			 *
 			 * Warn if we have other data frame types here,
 			 * they must not get here.
 			 */
 			WARN_ON(hdr->frame_control &
 					cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
 			WARN_ON(!(hdr->seq_ctrl &
 					cpu_to_le16(IEEE80211_SCTL_FRAG)));
 			/*
 			 * This was a fragment of a frame, received while
 			 * a block-ack session was active. That cannot be
 			 * right, so terminate the session.
 			 */
 			mutex_lock(&local->sta_mtx);
 			sta = sta_info_get_bss(sdata, mgmt->sa);
 			if (sta) {
 				u16 tid = *ieee80211_get_qos_ctl(hdr) &
 						IEEE80211_QOS_CTL_TID_MASK;
 				__ieee80211_stop_rx_ba_session(
 					sta, tid, WLAN_BACK_RECIPIENT,
 					WLAN_REASON_QSTA_REQUIRE_SETUP,
 					true);
 			}
 			mutex_unlock(&local->sta_mtx);
 		} else switch (sdata->vif.type) {
 		case NL80211_IFTYPE_STATION:
 			ieee80211_sta_rx_queued_mgmt(sdata, skb);
 			break;
 		case NL80211_IFTYPE_ADHOC:
 			ieee80211_ibss_rx_queued_mgmt(sdata, skb);
 			break;
 		case NL80211_IFTYPE_MESH_POINT:
 			if (!ieee80211_vif_is_mesh(&sdata->vif))
 				break;
 			ieee80211_mesh_rx_queued_mgmt(sdata, skb);
 			break;
 		default:
 			WARN(1, "frame for unexpected interface type");
 			break;
 		}
 		kfree_skb(skb);
 	}
 	/* then other type-dependent work */
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_STATION:
 		ieee80211_sta_work(sdata);
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		ieee80211_ibss_work(sdata);
 		break;
 	case NL80211_IFTYPE_MESH_POINT:
 		if (!ieee80211_vif_is_mesh(&sdata->vif))
 			break;
 		ieee80211_mesh_work(sdata);
 		break;
 	default:
 		break;
 	}
 }
 static void ieee80211_recalc_smps_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data, recalc_smps);
 	ieee80211_recalc_smps(sdata);
 }
 /*
  * Helper function to initialise an interface to a specific type.
  */
 static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
 				  enum nl80211_iftype type)
 {
 	/* clear type-dependent union */
 	memset(&sdata->u, 0, sizeof(sdata->u));
 	/* and set some type-dependent values */
 	sdata->vif.type = type;
 	sdata->vif.p2p = false;
 	sdata->wdev.iftype = type;
 	sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
 	sdata->control_port_no_encrypt = false;
 	sdata->noack_map = 0;
 	/* only monitor/p2p-device differ */
 	if (sdata->dev) {
 		sdata->dev->netdev_ops = &ieee80211_dataif_ops;
 		sdata->dev->type = ARPHRD_ETHER;
 	}
 	skb_queue_head_init(&sdata->skb_queue);
 	INIT_WORK(&sdata->work, ieee80211_iface_work);
 	INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
 	switch (type) {
 	case NL80211_IFTYPE_P2P_GO:
 		type = NL80211_IFTYPE_AP;
 		sdata->vif.type = type;
 		sdata->vif.p2p = true;
 		/* fall through */
 	case NL80211_IFTYPE_AP:
 		skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
 		INIT_LIST_HEAD(&sdata->u.ap.vlans);
 		sdata->vif.bss_conf.bssid = sdata->vif.addr;
 		break;
 	case NL80211_IFTYPE_P2P_CLIENT:
 		type = NL80211_IFTYPE_STATION;
 		sdata->vif.type = type;
 		sdata->vif.p2p = true;
 		/* fall through */
 	case NL80211_IFTYPE_STATION:
 		sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;
 		ieee80211_sta_setup_sdata(sdata);
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
 		ieee80211_ibss_setup_sdata(sdata);
 		break;
 	case NL80211_IFTYPE_MESH_POINT:
 		if (ieee80211_vif_is_mesh(&sdata->vif))
 			ieee80211_mesh_init_sdata(sdata);
 		break;
 	case NL80211_IFTYPE_MONITOR:
 		sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
 		sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
 		sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
 				      MONITOR_FLAG_OTHER_BSS;
 		break;
 	case NL80211_IFTYPE_WDS:
 		sdata->vif.bss_conf.bssid = NULL;
 		break;
 	case NL80211_IFTYPE_AP_VLAN:
 		break;
 	case NL80211_IFTYPE_P2P_DEVICE:
 		sdata->vif.bss_conf.bssid = sdata->vif.addr;
 		break;
 	case NL80211_IFTYPE_UNSPECIFIED:
 	case NUM_NL80211_IFTYPES:
 		BUG();
 		break;
 	}
 	ieee80211_debugfs_add_netdev(sdata);
 }
 static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
 					   enum nl80211_iftype type)
 {
 	struct ieee80211_local *local = sdata->local;
 	int ret, err;
 	enum nl80211_iftype internal_type = type;
 	bool p2p = false;
 	ASSERT_RTNL();
 	if (!local->ops->change_interface)
 		return -EBUSY;
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_AP:
 	case NL80211_IFTYPE_STATION:
 	case NL80211_IFTYPE_ADHOC:
 		/*
 		 * Could maybe also all others here?
 		 * Just not sure how that interacts
 		 * with the RX/config path e.g. for
 		 * mesh.
 		 */
 		break;
 	default:
 		return -EBUSY;
 	}
 	switch (type) {
 	case NL80211_IFTYPE_AP:
 	case NL80211_IFTYPE_STATION:
 	case NL80211_IFTYPE_ADHOC:
 		/*
 		 * Could probably support everything
 		 * but WDS here (WDS do_open can fail
 		 * under memory pressure, which this
 		 * code isn't prepared to handle).
 		 */
 		break;
 	case NL80211_IFTYPE_P2P_CLIENT:
 		p2p = true;
 		internal_type = NL80211_IFTYPE_STATION;
 		break;
 	case NL80211_IFTYPE_P2P_GO:
 		p2p = true;
 		internal_type = NL80211_IFTYPE_AP;
 		break;
 	default:
 		return -EBUSY;
 	}
 	ret = ieee80211_check_concurrent_iface(sdata, internal_type);
 	if (ret)
 		return ret;
 	ieee80211_do_stop(sdata, false);
 	ieee80211_teardown_sdata(sdata);
 	ret = drv_change_interface(local, sdata, internal_type, p2p);
 	if (ret)
 		type = sdata->vif.type;
 	/*
 	 * Ignore return value here, there's not much we can do since
 	 * the driver changed the interface type internally already.
 	 * The warnings will hopefully make driver authors fix it :-)
 	 */
 	ieee80211_check_queues(sdata);
 	ieee80211_setup_sdata(sdata, type);
 	err = ieee80211_do_open(&sdata->wdev, false);
 	WARN(err, "type change: do_open returned %d", err);
 	return ret;
 }
 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
 			     enum nl80211_iftype type)
 {
 	int ret;
 	ASSERT_RTNL();
 	if (type == ieee80211_vif_type_p2p(&sdata->vif))
 		return 0;
 	if (ieee80211_sdata_running(sdata)) {
 		ret = ieee80211_runtime_change_iftype(sdata, type);
 		if (ret)
 			return ret;
 	} else {
 		/* Purge and reset type-dependent state. */
 		ieee80211_teardown_sdata(sdata);
 		ieee80211_setup_sdata(sdata, type);
 	}
 	/* reset some values that shouldn't be kept across type changes */
 	sdata->drop_unencrypted = 0;
 	if (type == NL80211_IFTYPE_STATION)
 		sdata->u.mgd.use_4addr = false;
 	return 0;
 }
 static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
 				       u8 *perm_addr, enum nl80211_iftype type)
 {
 	struct ieee80211_sub_if_data *sdata;
 	u64 mask, start, addr, val, inc;
 	u8 *m;
 	u8 tmp_addr[ETH_ALEN];
 	int i;
 	/* default ... something at least */
 	memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
 	if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
 	    local->hw.wiphy->n_addresses <= 1)
 		return;
 	mutex_lock(&local->iflist_mtx);
 	switch (type) {
 	case NL80211_IFTYPE_MONITOR:
 		/* doesn't matter */
 		break;
 	case NL80211_IFTYPE_WDS:
 	case NL80211_IFTYPE_AP_VLAN:
 		/* match up with an AP interface */
 		list_for_each_entry(sdata, &local->interfaces, list) {
 			if (sdata->vif.type != NL80211_IFTYPE_AP)
 				continue;
 			memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
 			break;
 		}
 		/* keep default if no AP interface present */
 		break;
 	case NL80211_IFTYPE_P2P_CLIENT:
 	case NL80211_IFTYPE_P2P_GO:
 		if (local->hw.flags & IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF) {
 			list_for_each_entry(sdata, &local->interfaces, list) {
 				if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
 					continue;
 				if (!ieee80211_sdata_running(sdata))
 					continue;
 				memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
 				goto out_unlock;
 			}
 		}
 		/* otherwise fall through */
 	default:
 		/* assign a new address if possible -- try n_addresses first */
 		for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
 			bool used = false;
 			list_for_each_entry(sdata, &local->interfaces, list) {
 				if (memcmp(local->hw.wiphy->addresses[i].addr,
 					   sdata->vif.addr, ETH_ALEN) == 0) {
 					used = true;
 					break;
 				}
 			}
 			if (!used) {
 				memcpy(perm_addr,
 				       local->hw.wiphy->addresses[i].addr,
 				       ETH_ALEN);
 				break;
 			}
 		}
 		/* try mask if available */
 		if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
 			break;
 		m = local->hw.wiphy->addr_mask;
 		mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
 		if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
 			/* not a contiguous mask ... not handled now! */
 			pr_info("not contiguous\n");
 			break;
 		}
 		m = local->hw.wiphy->perm_addr;
 		start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
 		inc = 1ULL<<__ffs64(mask);
 		val = (start & mask);
 		addr = (start & ~mask) | (val & mask);
 		do {
 			bool used = false;
 			tmp_addr[5] = addr >> 0*8;
 			tmp_addr[4] = addr >> 1*8;
 			tmp_addr[3] = addr >> 2*8;
 			tmp_addr[2] = addr >> 3*8;
 			tmp_addr[1] = addr >> 4*8;
 			tmp_addr[0] = addr >> 5*8;
 			val += inc;
 			list_for_each_entry(sdata, &local->interfaces, list) {
 				if (memcmp(tmp_addr, sdata->vif.addr,
 							ETH_ALEN) == 0) {
 					used = true;
 					break;
 				}
 			}
 			if (!used) {
 				memcpy(perm_addr, tmp_addr, ETH_ALEN);
 				break;
 			}
 			addr = (start & ~mask) | (val & mask);
 		} while (addr != start);
 		break;
 	}
  out_unlock:
 	mutex_unlock(&local->iflist_mtx);
 }
 static void ieee80211_cleanup_sdata_stas_wk(struct work_struct *wk)
 {
 	struct ieee80211_sub_if_data *sdata;
 	sdata = container_of(wk, struct ieee80211_sub_if_data, cleanup_stations_wk);
 	ieee80211_cleanup_sdata_stas(sdata);
 }
 int ieee80211_if_add(struct ieee80211_local *local, const char *name,
 		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
 		     struct vif_params *params)
 {
 	struct net_device *ndev = NULL;
 	struct ieee80211_sub_if_data *sdata = NULL;
 	int ret, i;
 	int txqs = 1;
 	ASSERT_RTNL();
 	if (type == NL80211_IFTYPE_P2P_DEVICE) {
 		struct wireless_dev *wdev;
 		sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,
 				GFP_KERNEL);
 		if (!sdata)
 			return -ENOMEM;
 		wdev = &sdata->wdev;
 		sdata->dev = NULL;
 		strlcpy(sdata->name, name, IFNAMSIZ);
 		ieee80211_assign_perm_addr(local, wdev->address, type);
 		memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
 	} else {
 		if (local->hw.queues >= IEEE80211_NUM_ACS)
 			txqs = IEEE80211_NUM_ACS;
 		ndev = alloc_netdev_mqs(sizeof(*sdata) +
 					local->hw.vif_data_size,
 					name, ieee80211_if_setup, txqs, 1);
 		if (!ndev)
 			return -ENOMEM;
 		dev_net_set(ndev, wiphy_net(local->hw.wiphy));
 		ndev->needed_headroom = local->tx_headroom +
 					4*6 /* four MAC addresses */
 					+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
 					+ 6 /* mesh */
 					+ 8 /* rfc1042/bridge tunnel */
 					- ETH_HLEN /* ethernet hard_header_len */
 					+ IEEE80211_ENCRYPT_HEADROOM;
 		ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
 		ret = dev_alloc_name(ndev, ndev->name);
 		if (ret < 0) {
 			free_netdev(ndev);
 			return ret;
 		}
 		ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
 		memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
 		SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
 		/* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */
 		sdata = netdev_priv(ndev);
 		ndev->ieee80211_ptr = &sdata->wdev;
 		memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
 		memcpy(sdata->name, ndev->name, IFNAMSIZ);
 		sdata->dev = ndev;
 	}
 	/* initialise type-independent data */
 	sdata->wdev.wiphy = local->hw.wiphy;
 	sdata->local = local;
 	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
 		skb_queue_head_init(&sdata->fragments[i].skb_list);
 	INIT_LIST_HEAD(&sdata->key_list);
 	spin_lock_init(&sdata->cleanup_stations_lock);
 	INIT_LIST_HEAD(&sdata->cleanup_stations);
 	INIT_WORK(&sdata->cleanup_stations_wk, ieee80211_cleanup_sdata_stas_wk);
 	INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work,
 			  ieee80211_dfs_cac_timer_work);
 	INIT_DELAYED_WORK(&sdata->dec_tailroom_needed_wk,
 			  ieee80211_delayed_tailroom_dec);
 	for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
 		struct ieee80211_supported_band *sband;
 		sband = local->hw.wiphy->bands[i];
 		sdata->rc_rateidx_mask[i] =
 			sband ? (1 << sband->n_bitrates) - 1 : 0;
 		if (sband)
 			memcpy(sdata->rc_rateidx_mcs_mask[i],
 			       sband->ht_cap.mcs.rx_mask,
 			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
 		else
 			memset(sdata->rc_rateidx_mcs_mask[i], 0,
 			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
 	}
 	ieee80211_set_default_queues(sdata);
 	sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
 	sdata->user_power_level = local->user_power_level;
 	/* setup type-dependent data */
 	ieee80211_setup_sdata(sdata, type);
 	if (ndev) {
 		if (params) {
 			ndev->ieee80211_ptr->use_4addr = params->use_4addr;
 			if (type == NL80211_IFTYPE_STATION)
 				sdata->u.mgd.use_4addr = params->use_4addr;
 		}
 		ndev->features |= local->hw.netdev_features;
 		ret = register_netdevice(ndev);
 		if (ret) {
 			free_netdev(ndev);
 			return ret;
 		}
 	}
 	mutex_lock(&local->iflist_mtx);
 	list_add_tail_rcu(&sdata->list, &local->interfaces);
 	mutex_unlock(&local->iflist_mtx);
 	if (new_wdev)
 		*new_wdev = &sdata->wdev;
 	return 0;
 }
 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
 {
 	ASSERT_RTNL();
 	mutex_lock(&sdata->local->iflist_mtx);
 	list_del_rcu(&sdata->list);
 	mutex_unlock(&sdata->local->iflist_mtx);
 	synchronize_rcu();
 	if (sdata->dev) {
 		unregister_netdevice(sdata->dev);
 	} else {
 		cfg80211_unregister_wdev(&sdata->wdev);
 		kfree(sdata);
 	}
 }
 void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)
 {
 	if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))
 		return;
 	ieee80211_do_stop(sdata, true);
 	ieee80211_teardown_sdata(sdata);
 }
 /*
  * Remove all interfaces, may only be called at hardware unregistration
  * time because it doesn't do RCU-safe list removals.
  */
 void ieee80211_remove_interfaces(struct ieee80211_local *local)
 {
 	struct ieee80211_sub_if_data *sdata, *tmp;
 	LIST_HEAD(unreg_list);
 	LIST_HEAD(wdev_list);
 	ASSERT_RTNL();
 	mutex_lock(&local->iflist_mtx);
 	list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
 		list_del(&sdata->list);
 		if (sdata->dev)
 			unregister_netdevice_queue(sdata->dev, &unreg_list);
 		else
 			list_add(&sdata->list, &wdev_list);
 	}
 	mutex_unlock(&local->iflist_mtx);
 	unregister_netdevice_many(&unreg_list);
 	list_del(&unreg_list);
 	list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {
 		list_del(&sdata->list);
 		cfg80211_unregister_wdev(&sdata->wdev);
 		kfree(sdata);
 	}
 }
 static int netdev_notify(struct notifier_block *nb,
 			 unsigned long state,
 			 void *ndev)
 {
 	struct net_device *dev = ndev;
 	struct ieee80211_sub_if_data *sdata;
 	if (state != NETDEV_CHANGENAME)
 		return 0;
 	if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
 		return 0;
 	if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
 		return 0;
 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	memcpy(sdata->name, dev->name, IFNAMSIZ);
 	ieee80211_debugfs_rename_netdev(sdata);
 	return 0;
 }
 static struct notifier_block mac80211_netdev_notifier = {
 	.notifier_call = netdev_notify,
 };
 int ieee80211_iface_init(void)
 {
 	return register_netdevice_notifier(&mac80211_netdev_notifier);
 }
 void ieee80211_iface_exit(void)
 {
 	unregister_netdevice_notifier(&mac80211_netdev_notifier);