chan.c 9.1 KB
Newer Older
1 2 3 4
/*
 * mac80211 - channel management
 */

5
#include <linux/nl80211.h>
6
#include <net/cfg80211.h>
7
#include "ieee80211_i.h"
8
#include "driver-ops.h"
9

J
Johannes Berg 已提交
10
static enum ieee80211_chan_mode
11 12 13 14 15
__ieee80211_get_channel_mode(struct ieee80211_local *local,
			     struct ieee80211_sub_if_data *ignore)
{
	struct ieee80211_sub_if_data *sdata;

16
	lockdep_assert_held(&local->iflist_mtx);
17 18 19 20 21 22 23 24

	list_for_each_entry(sdata, &local->interfaces, list) {
		if (sdata == ignore)
			continue;

		if (!ieee80211_sdata_running(sdata))
			continue;

25 26
		switch (sdata->vif.type) {
		case NL80211_IFTYPE_MONITOR:
27
			continue;
28 29 30 31 32
		case NL80211_IFTYPE_STATION:
			if (!sdata->u.mgd.associated)
				continue;
			break;
		case NL80211_IFTYPE_ADHOC:
33 34 35 36
			if (!sdata->u.ibss.ssid_len)
				continue;
			if (!sdata->u.ibss.fixed_channel)
				return CHAN_MODE_HOPPING;
37 38 39
			break;
		case NL80211_IFTYPE_AP_VLAN:
			/* will also have _AP interface */
40
			continue;
41 42 43 44
		case NL80211_IFTYPE_AP:
			if (!sdata->u.ap.beacon)
				continue;
			break;
45 46 47 48
		case NL80211_IFTYPE_MESH_POINT:
			if (!sdata->wdev.mesh_id_len)
				continue;
			break;
49 50 51
		default:
			break;
		}
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

		return CHAN_MODE_FIXED;
	}

	return CHAN_MODE_UNDEFINED;
}

enum ieee80211_chan_mode
ieee80211_get_channel_mode(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *ignore)
{
	enum ieee80211_chan_mode mode;

	mutex_lock(&local->iflist_mtx);
	mode = __ieee80211_get_channel_mode(local, ignore);
	mutex_unlock(&local->iflist_mtx);

	return mode;
}
71

72 73 74
static enum nl80211_channel_type
ieee80211_get_superchan(struct ieee80211_local *local,
			struct ieee80211_sub_if_data *sdata)
75 76
{
	enum nl80211_channel_type superchan = NL80211_CHAN_NO_HT;
77
	struct ieee80211_sub_if_data *tmp;
78 79 80 81 82 83 84 85 86 87 88 89

	mutex_lock(&local->iflist_mtx);
	list_for_each_entry(tmp, &local->interfaces, list) {
		if (tmp == sdata)
			continue;

		if (!ieee80211_sdata_running(tmp))
			continue;

		switch (tmp->vif.bss_conf.channel_type) {
		case NL80211_CHAN_NO_HT:
		case NL80211_CHAN_HT20:
90 91 92
			if (superchan > tmp->vif.bss_conf.channel_type)
				break;

93 94 95 96 97 98 99 100 101 102 103 104
			superchan = tmp->vif.bss_conf.channel_type;
			break;
		case NL80211_CHAN_HT40PLUS:
			WARN_ON(superchan == NL80211_CHAN_HT40MINUS);
			superchan = NL80211_CHAN_HT40PLUS;
			break;
		case NL80211_CHAN_HT40MINUS:
			WARN_ON(superchan == NL80211_CHAN_HT40PLUS);
			superchan = NL80211_CHAN_HT40MINUS;
			break;
		}
	}
105
	mutex_unlock(&local->iflist_mtx);
106

107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
	return superchan;
}

static bool
ieee80211_channel_types_are_compatible(enum nl80211_channel_type chantype1,
				       enum nl80211_channel_type chantype2,
				       enum nl80211_channel_type *compat)
{
	/*
	 * start out with chantype1 being the result,
	 * overwriting later if needed
	 */
	if (compat)
		*compat = chantype1;

	switch (chantype1) {
123
	case NL80211_CHAN_NO_HT:
124 125 126
		if (compat)
			*compat = chantype2;
		break;
127 128 129 130 131
	case NL80211_CHAN_HT20:
		/*
		 * allow any change that doesn't go to no-HT
		 * (if it already is no-HT no change is needed)
		 */
132
		if (chantype2 == NL80211_CHAN_NO_HT)
133
			break;
134 135
		if (compat)
			*compat = chantype2;
136 137 138 139
		break;
	case NL80211_CHAN_HT40PLUS:
	case NL80211_CHAN_HT40MINUS:
		/* allow smaller bandwidth and same */
140
		if (chantype2 == NL80211_CHAN_NO_HT)
141
			break;
142
		if (chantype2 == NL80211_CHAN_HT20)
143
			break;
144
		if (chantype2 == chantype1)
145
			break;
146
		return false;
147 148
	}

149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
	return true;
}

bool ieee80211_set_channel_type(struct ieee80211_local *local,
				struct ieee80211_sub_if_data *sdata,
				enum nl80211_channel_type chantype)
{
	enum nl80211_channel_type superchan;
	enum nl80211_channel_type compatchan;

	superchan = ieee80211_get_superchan(local, sdata);
	if (!ieee80211_channel_types_are_compatible(superchan, chantype,
						    &compatchan))
		return false;

	local->_oper_channel_type = compatchan;
165 166 167 168

	if (sdata)
		sdata->vif.bss_conf.channel_type = chantype;

169
	return true;
170 171 172 173 174 175 176 177
}

static void ieee80211_change_chantype(struct ieee80211_local *local,
				      struct ieee80211_chanctx *ctx,
				      enum nl80211_channel_type chantype)
{
	if (chantype == ctx->conf.channel_type)
		return;
178

179 180
	ctx->conf.channel_type = chantype;
	drv_change_chanctx(local, ctx, IEEE80211_CHANCTX_CHANGE_CHANNEL_TYPE);
181
}
182 183 184 185 186 187 188 189

static struct ieee80211_chanctx *
ieee80211_find_chanctx(struct ieee80211_local *local,
		       struct ieee80211_channel *channel,
		       enum nl80211_channel_type channel_type,
		       enum ieee80211_chanctx_mode mode)
{
	struct ieee80211_chanctx *ctx;
190
	enum nl80211_channel_type compat_type;
191 192 193 194 195 196 197 198 199

	lockdep_assert_held(&local->chanctx_mtx);

	if (mode == IEEE80211_CHANCTX_EXCLUSIVE)
		return NULL;
	if (WARN_ON(!channel))
		return NULL;

	list_for_each_entry(ctx, &local->chanctx_list, list) {
200 201
		compat_type = ctx->conf.channel_type;

202 203 204 205
		if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE)
			continue;
		if (ctx->conf.channel != channel)
			continue;
206 207 208
		if (!ieee80211_channel_types_are_compatible(ctx->conf.channel_type,
							    channel_type,
							    &compat_type))
209 210
			continue;

211 212
		ieee80211_change_chantype(local, ctx, compat_type);

213 214 215 216 217 218 219 220 221 222 223 224 225
		return ctx;
	}

	return NULL;
}

static struct ieee80211_chanctx *
ieee80211_new_chanctx(struct ieee80211_local *local,
		      struct ieee80211_channel *channel,
		      enum nl80211_channel_type channel_type,
		      enum ieee80211_chanctx_mode mode)
{
	struct ieee80211_chanctx *ctx;
226
	int err;
227 228 229 230 231 232 233 234 235 236 237

	lockdep_assert_held(&local->chanctx_mtx);

	ctx = kzalloc(sizeof(*ctx) + local->hw.chanctx_data_size, GFP_KERNEL);
	if (!ctx)
		return ERR_PTR(-ENOMEM);

	ctx->conf.channel = channel;
	ctx->conf.channel_type = channel_type;
	ctx->mode = mode;

238 239 240 241 242 243
	err = drv_add_chanctx(local, ctx);
	if (err) {
		kfree(ctx);
		return ERR_PTR(err);
	}

244 245 246 247 248 249 250 251 252 253 254 255
	list_add(&ctx->list, &local->chanctx_list);

	return ctx;
}

static void ieee80211_free_chanctx(struct ieee80211_local *local,
				   struct ieee80211_chanctx *ctx)
{
	lockdep_assert_held(&local->chanctx_mtx);

	WARN_ON_ONCE(ctx->refcount != 0);

256 257
	drv_remove_chanctx(local, ctx);

258 259 260 261 262 263 264
	list_del(&ctx->list);
	kfree_rcu(ctx, rcu_head);
}

static int ieee80211_assign_vif_chanctx(struct ieee80211_sub_if_data *sdata,
					struct ieee80211_chanctx *ctx)
{
265 266
	struct ieee80211_local *local = sdata->local;
	int ret;
267 268 269

	lockdep_assert_held(&local->chanctx_mtx);

270 271 272 273
	ret = drv_assign_vif_chanctx(local, sdata, ctx);
	if (ret)
		return ret;

274 275 276 277 278 279
	rcu_assign_pointer(sdata->vif.chanctx_conf, &ctx->conf);
	ctx->refcount++;

	return 0;
}

280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
static enum nl80211_channel_type
ieee80211_calc_chantype(struct ieee80211_local *local,
			struct ieee80211_chanctx *ctx)
{
	struct ieee80211_chanctx_conf *conf = &ctx->conf;
	struct ieee80211_sub_if_data *sdata;
	enum nl80211_channel_type result = NL80211_CHAN_NO_HT;

	lockdep_assert_held(&local->chanctx_mtx);

	rcu_read_lock();
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
		if (!ieee80211_sdata_running(sdata))
			continue;
		if (rcu_access_pointer(sdata->vif.chanctx_conf) != conf)
			continue;

		WARN_ON_ONCE(!ieee80211_channel_types_are_compatible(
					sdata->vif.bss_conf.channel_type,
					result, &result));
	}
	rcu_read_unlock();

	return result;
}

static void ieee80211_recalc_chanctx_chantype(struct ieee80211_local *local,
					      struct ieee80211_chanctx *ctx)
{
	enum nl80211_channel_type chantype;

	lockdep_assert_held(&local->chanctx_mtx);

	chantype = ieee80211_calc_chantype(local, ctx);
	ieee80211_change_chantype(local, ctx, chantype);
}

317 318 319
static void ieee80211_unassign_vif_chanctx(struct ieee80211_sub_if_data *sdata,
					   struct ieee80211_chanctx *ctx)
{
320
	struct ieee80211_local *local = sdata->local;
321 322 323 324 325

	lockdep_assert_held(&local->chanctx_mtx);

	ctx->refcount--;
	rcu_assign_pointer(sdata->vif.chanctx_conf, NULL);
326 327

	drv_unassign_vif_chanctx(local, sdata, ctx);
328 329 330

	if (ctx->refcount > 0)
		ieee80211_recalc_chanctx_chantype(sdata->local, ctx);
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
}

static void __ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_chanctx_conf *conf;
	struct ieee80211_chanctx *ctx;

	lockdep_assert_held(&local->chanctx_mtx);

	conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
					 lockdep_is_held(&local->chanctx_mtx));
	if (!conf)
		return;

	ctx = container_of(conf, struct ieee80211_chanctx, conf);

	ieee80211_unassign_vif_chanctx(sdata, ctx);
	if (ctx->refcount == 0)
		ieee80211_free_chanctx(local, ctx);
}

int ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
			      struct ieee80211_channel *channel,
			      enum nl80211_channel_type channel_type,
			      enum ieee80211_chanctx_mode mode)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_chanctx *ctx;
	int ret;

	mutex_lock(&local->chanctx_mtx);
	__ieee80211_vif_release_channel(sdata);

	ctx = ieee80211_find_chanctx(local, channel, channel_type, mode);
	if (!ctx)
		ctx = ieee80211_new_chanctx(local, channel, channel_type, mode);
	if (IS_ERR(ctx)) {
		ret = PTR_ERR(ctx);
		goto out;
	}

	ret = ieee80211_assign_vif_chanctx(sdata, ctx);
	if (ret) {
		/* if assign fails refcount stays the same */
		if (ctx->refcount == 0)
			ieee80211_free_chanctx(local, ctx);
		goto out;
	}

 out:
	mutex_unlock(&local->chanctx_mtx);
	return ret;
}

void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata)
{
	mutex_lock(&sdata->local->chanctx_mtx);
	__ieee80211_vif_release_channel(sdata);
	mutex_unlock(&sdata->local->chanctx_mtx);
}