PageRenderTime 2248ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/net/wireless/libertas/cfg.c

https://bitbucket.org/slukk/jb-tsm-kernel-4.2
C | 2187 lines | 1310 code | 365 blank | 512 comment | 163 complexity | 6064a321533146716a53f88ea90eb21a MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.  * Implement cfg80211 ("iw") support.
    3. 

  3.  *
    4. 

  4.  * Copyright (C) 2009 M&N Solutions GmbH, 61191 Rosbach, Germany
    5. 

  5.  * Holger Schurig <hs4233@mail.mn-solutions.de>
    6. 

  6.  *
    7. 

  7.  */
    8. 

  8. 

  9. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
    10. 

  10. 

  11. #include <linux/sched.h>
    12. 

  12. #include <linux/wait.h>
    13. 

  13. #include <linux/slab.h>
    14. 

  14. #include <linux/ieee80211.h>
    15. 

  15. #include <net/cfg80211.h>
    16. 

  16. #include <asm/unaligned.h>
    17. 

  17. 

  18. #include "decl.h"
    19. 

  19. #include "cfg.h"
    20. 

  20. #include "cmd.h"
    21. 

  21. 

  22. 

  23. #define CHAN2G(_channel, _freq, _flags) {        \
    24. 

  24. 	.band             = IEEE80211_BAND_2GHZ, \
    25. 

  25. 	.center_freq      = (_freq),             \
    26. 

  26. 	.hw_value         = (_channel),          \
    27. 

  27. 	.flags            = (_flags),            \
    28. 

  28. 	.max_antenna_gain = 0,                   \
    29. 

  29. 	.max_power        = 30,                  \
    30. 

  30. }
    31. 

  31. 

  32. static struct ieee80211_channel lbs_2ghz_channels[] = {
    33. 

  33. 	CHAN2G(1,  2412, 0),
    34. 

  34. 	CHAN2G(2,  2417, 0),
    35. 

  35. 	CHAN2G(3,  2422, 0),
    36. 

  36. 	CHAN2G(4,  2427, 0),
    37. 

  37. 	CHAN2G(5,  2432, 0),
    38. 

  38. 	CHAN2G(6,  2437, 0),
    39. 

  39. 	CHAN2G(7,  2442, 0),
    40. 

  40. 	CHAN2G(8,  2447, 0),
    41. 

  41. 	CHAN2G(9,  2452, 0),
    42. 

  42. 	CHAN2G(10, 2457, 0),
    43. 

  43. 	CHAN2G(11, 2462, 0),
    44. 

  44. 	CHAN2G(12, 2467, 0),
    45. 

  45. 	CHAN2G(13, 2472, 0),
    46. 

  46. 	CHAN2G(14, 2484, 0),
    47. 

  47. };
    48. 

  48. 

  49. #define RATETAB_ENT(_rate, _hw_value, _flags) { \
    50. 

  50. 	.bitrate  = (_rate),                    \
    51. 

  51. 	.hw_value = (_hw_value),                \
    52. 

  52. 	.flags    = (_flags),                   \
    53. 

  53. }
    54. 

  54. 

  55. 

  56. /* Table 6 in section 3.2.1.1 */
    57. 

  57. static struct ieee80211_rate lbs_rates[] = {
    58. 

  58. 	RATETAB_ENT(10,  0,  0),
    59. 

  59. 	RATETAB_ENT(20,  1,  0),
    60. 

  60. 	RATETAB_ENT(55,  2,  0),
    61. 

  61. 	RATETAB_ENT(110, 3,  0),
    62. 

  62. 	RATETAB_ENT(60,  9,  0),
    63. 

  63. 	RATETAB_ENT(90,  6,  0),
    64. 

  64. 	RATETAB_ENT(120, 7,  0),
    65. 

  65. 	RATETAB_ENT(180, 8,  0),
    66. 

  66. 	RATETAB_ENT(240, 9,  0),
    67. 

  67. 	RATETAB_ENT(360, 10, 0),
    68. 

  68. 	RATETAB_ENT(480, 11, 0),
    69. 

  69. 	RATETAB_ENT(540, 12, 0),
    70. 

  70. };
    71. 

  71. 

  72. static struct ieee80211_supported_band lbs_band_2ghz = {
    73. 

  73. 	.channels = lbs_2ghz_channels,
    74. 

  74. 	.n_channels = ARRAY_SIZE(lbs_2ghz_channels),
    75. 

  75. 	.bitrates = lbs_rates,
    76. 

  76. 	.n_bitrates = ARRAY_SIZE(lbs_rates),
    77. 

  77. };
    78. 

  78. 

  79. 

  80. static const u32 cipher_suites[] = {
    81. 

  81. 	WLAN_CIPHER_SUITE_WEP40,
    82. 

  82. 	WLAN_CIPHER_SUITE_WEP104,
    83. 

  83. 	WLAN_CIPHER_SUITE_TKIP,
    84. 

  84. 	WLAN_CIPHER_SUITE_CCMP,
    85. 

  85. };
    86. 

  86. 

  87. /* Time to stay on the channel */
    88. 

  88. #define LBS_DWELL_PASSIVE 100
    89. 

  89. #define LBS_DWELL_ACTIVE  40
    90. 

  90. 

  91. 

  92. /***************************************************************************
    93. 

  93.  * Misc utility functions
    94. 

  94.  *
    95. 

  95.  * TLVs are Marvell specific. They are very similar to IEs, they have the
    96. 

  96.  * same structure: type, length, data*. The only difference: for IEs, the
    97. 

  97.  * type and length are u8, but for TLVs they're __le16.
    98. 

  98.  */
    99. 

  99. 

  100. /*
    101. 

  101.  * Convert NL80211's auth_type to the one from Libertas, see chapter 5.9.1
    102. 

  102.  * in the firmware spec
    103. 

  103.  */
    104. 

  104. static u8 lbs_auth_to_authtype(enum nl80211_auth_type auth_type)
    105. 

  105. {
    106. 

  106. 	int ret = -ENOTSUPP;
    107. 

  107. 

  108. 	switch (auth_type) {
    109. 

  109. 	case NL80211_AUTHTYPE_OPEN_SYSTEM:
    110. 

  110. 	case NL80211_AUTHTYPE_SHARED_KEY:
    111. 

  111. 		ret = auth_type;
    112. 

  112. 		break;
    113. 

  113. 	case NL80211_AUTHTYPE_AUTOMATIC:
    114. 

  114. 		ret = NL80211_AUTHTYPE_OPEN_SYSTEM;
    115. 

  115. 		break;
    116. 

  116. 	case NL80211_AUTHTYPE_NETWORK_EAP:
    117. 

  117. 		ret = 0x80;
    118. 

  118. 		break;
    119. 

  119. 	default:
    120. 

  120. 		/* silence compiler */
    121. 

  121. 		break;
    122. 

  122. 	}
    123. 

  123. 	return ret;
    124. 

  124. }
    125. 

  125. 

  126. 

  127. /*
    128. 

  128.  * Various firmware commands need the list of supported rates, but with
    129. 

  129.  * the hight-bit set for basic rates
    130. 

  130.  */
    131. 

  131. static int lbs_add_rates(u8 *rates)
    132. 

  132. {
    133. 

  133. 	size_t i;
    134. 

  134. 

  135. 	for (i = 0; i < ARRAY_SIZE(lbs_rates); i++) {
    136. 

  136. 		u8 rate = lbs_rates[i].bitrate / 5;
    137. 

  137. 		if (rate == 0x02 || rate == 0x04 ||
    138. 

  138. 		    rate == 0x0b || rate == 0x16)
    139. 

  139. 			rate |= 0x80;
    140. 

  140. 		rates[i] = rate;
    141. 

  141. 	}
    142. 

  142. 	return ARRAY_SIZE(lbs_rates);
    143. 

  143. }
    144. 

  144. 

  145. 

  146. /***************************************************************************
    147. 

  147.  * TLV utility functions
    148. 

  148.  *
    149. 

  149.  * TLVs are Marvell specific. They are very similar to IEs, they have the
    150. 

  150.  * same structure: type, length, data*. The only difference: for IEs, the
    151. 

  151.  * type and length are u8, but for TLVs they're __le16.
    152. 

  152.  */
    153. 

  153. 

  154. 

  155. /*
    156. 

  156.  * Add ssid TLV
    157. 

  157.  */
    158. 

  158. #define LBS_MAX_SSID_TLV_SIZE			\
    159. 

  159. 	(sizeof(struct mrvl_ie_header)		\
    160. 

  160. 	 + IEEE80211_MAX_SSID_LEN)
    161. 

  161. 

  162. static int lbs_add_ssid_tlv(u8 *tlv, const u8 *ssid, int ssid_len)
    163. 

  163. {
    164. 

  164. 	struct mrvl_ie_ssid_param_set *ssid_tlv = (void *)tlv;
    165. 

  165. 

  166. 	/*
    167. 

  167. 	 * TLV-ID SSID  00 00
    168. 

  168. 	 * length       06 00
    169. 

  169. 	 * ssid         4d 4e 54 45 53 54
    170. 

  170. 	 */
    171. 

  171. 	ssid_tlv->header.type = cpu_to_le16(TLV_TYPE_SSID);
    172. 

  172. 	ssid_tlv->header.len = cpu_to_le16(ssid_len);
    173. 

  173. 	memcpy(ssid_tlv->ssid, ssid, ssid_len);
    174. 

  174. 	return sizeof(ssid_tlv->header) + ssid_len;
    175. 

  175. }
    176. 

  176. 

  177. 

  178. /*
    179. 

  179.  * Add channel list TLV (section 8.4.2)
    180. 

  180.  *
    181. 

  181.  * Actual channel data comes from priv->wdev->wiphy->channels.
    182. 

  182.  */
    183. 

  183. #define LBS_MAX_CHANNEL_LIST_TLV_SIZE					\
    184. 

  184. 	(sizeof(struct mrvl_ie_header)					\
    185. 

  185. 	 + (LBS_SCAN_BEFORE_NAP * sizeof(struct chanscanparamset)))
    186. 

  186. 

  187. static int lbs_add_channel_list_tlv(struct lbs_private *priv, u8 *tlv,
    188. 

  188. 				    int last_channel, int active_scan)
    189. 

  189. {
    190. 

  190. 	int chanscanparamsize = sizeof(struct chanscanparamset) *
    191. 

  191. 		(last_channel - priv->scan_channel);
    192. 

  192. 

  193. 	struct mrvl_ie_header *header = (void *) tlv;
    194. 

  194. 

  195. 	/*
    196. 

  196. 	 * TLV-ID CHANLIST  01 01
    197. 

  197. 	 * length           0e 00
    198. 

  198. 	 * channel          00 01 00 00 00 64 00
    199. 

  199. 	 *   radio type     00
    200. 

  200. 	 *   channel           01
    201. 

  201. 	 *   scan type            00
    202. 

  202. 	 *   min scan time           00 00
    203. 

  203. 	 *   max scan time                 64 00
    204. 

  204. 	 * channel 2        00 02 00 00 00 64 00
    205. 

  205. 	 *
    206. 

  206. 	 */
    207. 

  207. 

  208. 	header->type = cpu_to_le16(TLV_TYPE_CHANLIST);
    209. 

  209. 	header->len  = cpu_to_le16(chanscanparamsize);
    210. 

  210. 	tlv += sizeof(struct mrvl_ie_header);
    211. 

  211. 

  212. 	/* lbs_deb_scan("scan: channels %d to %d\n", priv->scan_channel,
    213. 

  213. 		     last_channel); */
    214. 

  214. 	memset(tlv, 0, chanscanparamsize);
    215. 

  215. 

  216. 	while (priv->scan_channel < last_channel) {
    217. 

  217. 		struct chanscanparamset *param = (void *) tlv;
    218. 

  218. 

  219. 		param->radiotype = CMD_SCAN_RADIO_TYPE_BG;
    220. 

  220. 		param->channumber =
    221. 

  221. 			priv->scan_req->channels[priv->scan_channel]->hw_value;
    222. 

  222. 		if (active_scan) {
    223. 

  223. 			param->maxscantime = cpu_to_le16(LBS_DWELL_ACTIVE);
    224. 

  224. 		} else {
    225. 

  225. 			param->chanscanmode.passivescan = 1;
    226. 

  226. 			param->maxscantime = cpu_to_le16(LBS_DWELL_PASSIVE);
    227. 

  227. 		}
    228. 

  228. 		tlv += sizeof(struct chanscanparamset);
    229. 

  229. 		priv->scan_channel++;
    230. 

  230. 	}
    231. 

  231. 	return sizeof(struct mrvl_ie_header) + chanscanparamsize;
    232. 

  232. }
    233. 

  233. 

  234. 

  235. /*
    236. 

  236.  * Add rates TLV
    237. 

  237.  *
    238. 

  238.  * The rates are in lbs_bg_rates[], but for the 802.11b
    239. 

  239.  * rates the high bit is set. We add this TLV only because
    240. 

  240.  * there's a firmware which otherwise doesn't report all
    241. 

  241.  * APs in range.
    242. 

  242.  */
    243. 

  243. #define LBS_MAX_RATES_TLV_SIZE			\
    244. 

  244. 	(sizeof(struct mrvl_ie_header)		\
    245. 

  245. 	 + (ARRAY_SIZE(lbs_rates)))
    246. 

  246. 

  247. /* Adds a TLV with all rates the hardware supports */
    248. 

  248. static int lbs_add_supported_rates_tlv(u8 *tlv)
    249. 

  249. {
    250. 

  250. 	size_t i;
    251. 

  251. 	struct mrvl_ie_rates_param_set *rate_tlv = (void *)tlv;
    252. 

  252. 

  253. 	/*
    254. 

  254. 	 * TLV-ID RATES  01 00
    255. 

  255. 	 * length        0e 00
    256. 

  256. 	 * rates         82 84 8b 96 0c 12 18 24 30 48 60 6c
    257. 

  257. 	 */
    258. 

  258. 	rate_tlv->header.type = cpu_to_le16(TLV_TYPE_RATES);
    259. 

  259. 	tlv += sizeof(rate_tlv->header);
    260. 

  260. 	i = lbs_add_rates(tlv);
    261. 

  261. 	tlv += i;
    262. 

  262. 	rate_tlv->header.len = cpu_to_le16(i);
    263. 

  263. 	return sizeof(rate_tlv->header) + i;
    264. 

  264. }
    265. 

  265. 

  266. /* Add common rates from a TLV and return the new end of the TLV */
    267. 

  267. static u8 *
    268. 

  268. add_ie_rates(u8 *tlv, const u8 *ie, int *nrates)
    269. 

  269. {
    270. 

  270. 	int hw, ap, ap_max = ie[1];
    271. 

  271. 	u8 hw_rate;
    272. 

  272. 

  273. 	/* Advance past IE header */
    274. 

  274. 	ie += 2;
    275. 

  275. 

  276. 	lbs_deb_hex(LBS_DEB_ASSOC, "AP IE Rates", (u8 *) ie, ap_max);
    277. 

  277. 

  278. 	for (hw = 0; hw < ARRAY_SIZE(lbs_rates); hw++) {
    279. 

  279. 		hw_rate = lbs_rates[hw].bitrate / 5;
    280. 

  280. 		for (ap = 0; ap < ap_max; ap++) {
    281. 

  281. 			if (hw_rate == (ie[ap] & 0x7f)) {
    282. 

  282. 				*tlv++ = ie[ap];
    283. 

  283. 				*nrates = *nrates + 1;
    284. 

  284. 			}
    285. 

  285. 		}
    286. 

  286. 	}
    287. 

  287. 	return tlv;
    288. 

  288. }
    289. 

  289. 

  290. /*
    291. 

  291.  * Adds a TLV with all rates the hardware *and* BSS supports.
    292. 

  292.  */
    293. 

  293. static int lbs_add_common_rates_tlv(u8 *tlv, struct cfg80211_bss *bss)
    294. 

  294. {
    295. 

  295. 	struct mrvl_ie_rates_param_set *rate_tlv = (void *)tlv;
    296. 

  296. 	const u8 *rates_eid, *ext_rates_eid;
    297. 

  297. 	int n = 0;
    298. 

  298. 

  299. 	rates_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SUPP_RATES);
    300. 

  300. 	ext_rates_eid = ieee80211_bss_get_ie(bss, WLAN_EID_EXT_SUPP_RATES);
    301. 

  301. 

  302. 	/*
    303. 

  303. 	 * 01 00                   TLV_TYPE_RATES
    304. 

  304. 	 * 04 00                   len
    305. 

  305. 	 * 82 84 8b 96             rates
    306. 

  306. 	 */
    307. 

  307. 	rate_tlv->header.type = cpu_to_le16(TLV_TYPE_RATES);
    308. 

  308. 	tlv += sizeof(rate_tlv->header);
    309. 

  309. 

  310. 	/* Add basic rates */
    311. 

  311. 	if (rates_eid) {
    312. 

  312. 		tlv = add_ie_rates(tlv, rates_eid, &n);
    313. 

  313. 

  314. 		/* Add extended rates, if any */
    315. 

  315. 		if (ext_rates_eid)
    316. 

  316. 			tlv = add_ie_rates(tlv, ext_rates_eid, &n);
    317. 

  317. 	} else {
    318. 

  318. 		lbs_deb_assoc("assoc: bss had no basic rate IE\n");
    319. 

  319. 		/* Fallback: add basic 802.11b rates */
    320. 

  320. 		*tlv++ = 0x82;
    321. 

  321. 		*tlv++ = 0x84;
    322. 

  322. 		*tlv++ = 0x8b;
    323. 

  323. 		*tlv++ = 0x96;
    324. 

  324. 		n = 4;
    325. 

  325. 	}
    326. 

  326. 

  327. 	rate_tlv->header.len = cpu_to_le16(n);
    328. 

  328. 	return sizeof(rate_tlv->header) + n;
    329. 

  329. }
    330. 

  330. 

  331. 

  332. /*
    333. 

  333.  * Add auth type TLV.
    334. 

  334.  *
    335. 

  335.  * This is only needed for newer firmware (V9 and up).
    336. 

  336.  */
    337. 

  337. #define LBS_MAX_AUTH_TYPE_TLV_SIZE \
    338. 

  338. 	sizeof(struct mrvl_ie_auth_type)
    339. 

  339. 

  340. static int lbs_add_auth_type_tlv(u8 *tlv, enum nl80211_auth_type auth_type)
    341. 

  341. {
    342. 

  342. 	struct mrvl_ie_auth_type *auth = (void *) tlv;
    343. 

  343. 

  344. 	/*
    345. 

  345. 	 * 1f 01  TLV_TYPE_AUTH_TYPE
    346. 

  346. 	 * 01 00  len
    347. 

  347. 	 * 01     auth type
    348. 

  348. 	 */
    349. 

  349. 	auth->header.type = cpu_to_le16(TLV_TYPE_AUTH_TYPE);
    350. 

  350. 	auth->header.len = cpu_to_le16(sizeof(*auth)-sizeof(auth->header));
    351. 

  351. 	auth->auth = cpu_to_le16(lbs_auth_to_authtype(auth_type));
    352. 

  352. 	return sizeof(*auth);
    353. 

  353. }
    354. 

  354. 

  355. 

  356. /*
    357. 

  357.  * Add channel (phy ds) TLV
    358. 

  358.  */
    359. 

  359. #define LBS_MAX_CHANNEL_TLV_SIZE \
    360. 

  360. 	sizeof(struct mrvl_ie_header)
    361. 

  361. 

  362. static int lbs_add_channel_tlv(u8 *tlv, u8 channel)
    363. 

  363. {
    364. 

  364. 	struct mrvl_ie_ds_param_set *ds = (void *) tlv;
    365. 

  365. 

  366. 	/*
    367. 

  367. 	 * 03 00  TLV_TYPE_PHY_DS
    368. 

  368. 	 * 01 00  len
    369. 

  369. 	 * 06     channel
    370. 

  370. 	 */
    371. 

  371. 	ds->header.type = cpu_to_le16(TLV_TYPE_PHY_DS);
    372. 

  372. 	ds->header.len = cpu_to_le16(sizeof(*ds)-sizeof(ds->header));
    373. 

  373. 	ds->channel = channel;
    374. 

  374. 	return sizeof(*ds);
    375. 

  375. }
    376. 

  376. 

  377. 

  378. /*
    379. 

  379.  * Add (empty) CF param TLV of the form:
    380. 

  380.  */
    381. 

  381. #define LBS_MAX_CF_PARAM_TLV_SIZE		\
    382. 

  382. 	sizeof(struct mrvl_ie_header)
    383. 

  383. 

  384. static int lbs_add_cf_param_tlv(u8 *tlv)
    385. 

  385. {
    386. 

  386. 	struct mrvl_ie_cf_param_set *cf = (void *)tlv;
    387. 

  387. 

  388. 	/*
    389. 

  389. 	 * 04 00  TLV_TYPE_CF
    390. 

  390. 	 * 06 00  len
    391. 

  391. 	 * 00     cfpcnt
    392. 

  392. 	 * 00     cfpperiod
    393. 

  393. 	 * 00 00  cfpmaxduration
    394. 

  394. 	 * 00 00  cfpdurationremaining
    395. 

  395. 	 */
    396. 

  396. 	cf->header.type = cpu_to_le16(TLV_TYPE_CF);
    397. 

  397. 	cf->header.len = cpu_to_le16(sizeof(*cf)-sizeof(cf->header));
    398. 

  398. 	return sizeof(*cf);
    399. 

  399. }
    400. 

  400. 

  401. /*
    402. 

  402.  * Add WPA TLV
    403. 

  403.  */
    404. 

  404. #define LBS_MAX_WPA_TLV_SIZE			\
    405. 

  405. 	(sizeof(struct mrvl_ie_header)		\
    406. 

  406. 	 + 128 /* TODO: I guessed the size */)
    407. 

  407. 

  408. static int lbs_add_wpa_tlv(u8 *tlv, const u8 *ie, u8 ie_len)
    409. 

  409. {
    410. 

  410. 	size_t tlv_len;
    411. 

  411. 

  412. 	/*
    413. 

  413. 	 * We need just convert an IE to an TLV. IEs use u8 for the header,
    414. 

  414. 	 *   u8      type
    415. 

  415. 	 *   u8      len
    416. 

  416. 	 *   u8[]    data
    417. 

  417. 	 * but TLVs use __le16 instead:
    418. 

  418. 	 *   __le16  type
    419. 

  419. 	 *   __le16  len
    420. 

  420. 	 *   u8[]    data
    421. 

  421. 	 */
    422. 

  422. 	*tlv++ = *ie++;
    423. 

  423. 	*tlv++ = 0;
    424. 

  424. 	tlv_len = *tlv++ = *ie++;
    425. 

  425. 	*tlv++ = 0;
    426. 

  426. 	while (tlv_len--)
    427. 

  427. 		*tlv++ = *ie++;
    428. 

  428. 	/* the TLV is two bytes larger than the IE */
    429. 

  429. 	return ie_len + 2;
    430. 

  430. }
    431. 

  431. 

  432. /*
    433. 

  433.  * Set Channel
    434. 

  434.  */
    435. 

  435. 

  436. static int lbs_cfg_set_channel(struct wiphy *wiphy,
    437. 

  437. 	struct net_device *netdev,
    438. 

  438. 	struct ieee80211_channel *channel,
    439. 

  439. 	enum nl80211_channel_type channel_type)
    440. 

  440. {
    441. 

  441. 	struct lbs_private *priv = wiphy_priv(wiphy);
    442. 

  442. 	int ret = -ENOTSUPP;
    443. 

  443. 

  444. 	lbs_deb_enter_args(LBS_DEB_CFG80211, "freq %d, type %d",
    445. 

  445. 			   channel->center_freq, channel_type);
    446. 

  446. 

  447. 	if (channel_type != NL80211_CHAN_NO_HT)
    448. 

  448. 		goto out;
    449. 

  449. 

  450. 	ret = lbs_set_channel(priv, channel->hw_value);
    451. 

  451. 

  452.  out:
    453. 

  453. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    454. 

  454. 	return ret;
    455. 

  455. }
    456. 

  456. 

  457. 

  458. 

  459. /*
    460. 

  460.  * Scanning
    461. 

  461.  */
    462. 

  462. 

  463. /*
    464. 

  464.  * When scanning, the firmware doesn't send a nul packet with the power-safe
    465. 

  465.  * bit to the AP. So we cannot stay away from our current channel too long,
    466. 

  466.  * otherwise we loose data. So take a "nap" while scanning every other
    467. 

  467.  * while.
    468. 

  468.  */
    469. 

  469. #define LBS_SCAN_BEFORE_NAP 4
    470. 

  470. 

  471. 

  472. /*
    473. 

  473.  * When the firmware reports back a scan-result, it gives us an "u8 rssi",
    474. 

  474.  * which isn't really an RSSI, as it becomes larger when moving away from
    475. 

  475.  * the AP. Anyway, we need to convert that into mBm.
    476. 

  476.  */
    477. 

  477. #define LBS_SCAN_RSSI_TO_MBM(rssi) \
    478. 

  478. 	((-(int)rssi + 3)*100)
    479. 

  479. 

  480. static int lbs_ret_scan(struct lbs_private *priv, unsigned long dummy,
    481. 

  481. 	struct cmd_header *resp)
    482. 

  482. {
    483. 

  483. 	struct cmd_ds_802_11_scan_rsp *scanresp = (void *)resp;
    484. 

  484. 	int bsssize;
    485. 

  485. 	const u8 *pos;
    486. 

  486. 	const u8 *tsfdesc;
    487. 

  487. 	int tsfsize;
    488. 

  488. 	int i;
    489. 

  489. 	int ret = -EILSEQ;
    490. 

  490. 

  491. 	lbs_deb_enter(LBS_DEB_CFG80211);
    492. 

  492. 

  493. 	bsssize = get_unaligned_le16(&scanresp->bssdescriptsize);
    494. 

  494. 

  495. 	lbs_deb_scan("scan response: %d BSSs (%d bytes); resp size %d bytes\n",
    496. 

  496. 			scanresp->nr_sets, bsssize, le16_to_cpu(resp->size));
    497. 

  497. 

  498. 	if (scanresp->nr_sets == 0) {
    499. 

  499. 		ret = 0;
    500. 

  500. 		goto done;
    501. 

  501. 	}
    502. 

  502. 

  503. 	/*
    504. 

  504. 	 * The general layout of the scan response is described in chapter
    505. 

  505. 	 * 5.7.1. Basically we have a common part, then any number of BSS
    506. 

  506. 	 * descriptor sections. Finally we have section with the same number
    507. 

  507. 	 * of TSFs.
    508. 

  508. 	 *
    509. 

  509. 	 * cmd_ds_802_11_scan_rsp
    510. 

  510. 	 *   cmd_header
    511. 

  511. 	 *   pos_size
    512. 

  512. 	 *   nr_sets
    513. 

  513. 	 *   bssdesc 1
    514. 

  514. 	 *     bssid
    515. 

  515. 	 *     rssi
    516. 

  516. 	 *     timestamp
    517. 

  517. 	 *     intvl
    518. 

  518. 	 *     capa
    519. 

  519. 	 *     IEs
    520. 

  520. 	 *   bssdesc 2
    521. 

  521. 	 *   bssdesc n
    522. 

  522. 	 *   MrvlIEtypes_TsfFimestamp_t
    523. 

  523. 	 *     TSF for BSS 1
    524. 

  524. 	 *     TSF for BSS 2
    525. 

  525. 	 *     TSF for BSS n
    526. 

  526. 	 */
    527. 

  527. 

  528. 	pos = scanresp->bssdesc_and_tlvbuffer;
    529. 

  529. 

  530. 	lbs_deb_hex(LBS_DEB_SCAN, "SCAN_RSP", scanresp->bssdesc_and_tlvbuffer,
    531. 

  531. 			scanresp->bssdescriptsize);
    532. 

  532. 

  533. 	tsfdesc = pos + bsssize;
    534. 

  534. 	tsfsize = 4 + 8 * scanresp->nr_sets;
    535. 

  535. 	lbs_deb_hex(LBS_DEB_SCAN, "SCAN_TSF", (u8 *) tsfdesc, tsfsize);
    536. 

  536. 

  537. 	/* Validity check: we expect a Marvell-Local TLV */
    538. 

  538. 	i = get_unaligned_le16(tsfdesc);
    539. 

  539. 	tsfdesc += 2;
    540. 

  540. 	if (i != TLV_TYPE_TSFTIMESTAMP) {
    541. 

  541. 		lbs_deb_scan("scan response: invalid TSF Timestamp %d\n", i);
    542. 

  542. 		goto done;
    543. 

  543. 	}
    544. 

  544. 

  545. 	/*
    546. 

  546. 	 * Validity check: the TLV holds TSF values with 8 bytes each, so
    547. 

  547. 	 * the size in the TLV must match the nr_sets value
    548. 

  548. 	 */
    549. 

  549. 	i = get_unaligned_le16(tsfdesc);
    550. 

  550. 	tsfdesc += 2;
    551. 

  551. 	if (i / 8 != scanresp->nr_sets) {
    552. 

  552. 		lbs_deb_scan("scan response: invalid number of TSF timestamp "
    553. 

  553. 			     "sets (expected %d got %d)\n", scanresp->nr_sets,
    554. 

  554. 			     i / 8);
    555. 

  555. 		goto done;
    556. 

  556. 	}
    557. 

  557. 

  558. 	for (i = 0; i < scanresp->nr_sets; i++) {
    559. 

  559. 		const u8 *bssid;
    560. 

  560. 		const u8 *ie;
    561. 

  561. 		int left;
    562. 

  562. 		int ielen;
    563. 

  563. 		int rssi;
    564. 

  564. 		u16 intvl;
    565. 

  565. 		u16 capa;
    566. 

  566. 		int chan_no = -1;
    567. 

  567. 		const u8 *ssid = NULL;
    568. 

  568. 		u8 ssid_len = 0;
    569. 

  569. 		DECLARE_SSID_BUF(ssid_buf);
    570. 

  570. 

  571. 		int len = get_unaligned_le16(pos);
    572. 

  572. 		pos += 2;
    573. 

  573. 

  574. 		/* BSSID */
    575. 

  575. 		bssid = pos;
    576. 

  576. 		pos += ETH_ALEN;
    577. 

  577. 		/* RSSI */
    578. 

  578. 		rssi = *pos++;
    579. 

  579. 		/* Packet time stamp */
    580. 

  580. 		pos += 8;
    581. 

  581. 		/* Beacon interval */
    582. 

  582. 		intvl = get_unaligned_le16(pos);
    583. 

  583. 		pos += 2;
    584. 

  584. 		/* Capabilities */
    585. 

  585. 		capa = get_unaligned_le16(pos);
    586. 

  586. 		pos += 2;
    587. 

  587. 

  588. 		/* To find out the channel, we must parse the IEs */
    589. 

  589. 		ie = pos;
    590. 

  590. 		/*
    591. 

  591. 		 * 6+1+8+2+2: size of BSSID, RSSI, time stamp, beacon
    592. 

  592. 		 * interval, capabilities
    593. 

  593. 		 */
    594. 

  594. 		ielen = left = len - (6 + 1 + 8 + 2 + 2);
    595. 

  595. 		while (left >= 2) {
    596. 

  596. 			u8 id, elen;
    597. 

  597. 			id = *pos++;
    598. 

  598. 			elen = *pos++;
    599. 

  599. 			left -= 2;
    600. 

  600. 			if (elen > left || elen == 0) {
    601. 

  601. 				lbs_deb_scan("scan response: invalid IE fmt\n");
    602. 

  602. 				goto done;
    603. 

  603. 			}
    604. 

  604. 

  605. 			if (id == WLAN_EID_DS_PARAMS)
    606. 

  606. 				chan_no = *pos;
    607. 

  607. 			if (id == WLAN_EID_SSID) {
    608. 

  608. 				ssid = pos;
    609. 

  609. 				ssid_len = elen;
    610. 

  610. 			}
    611. 

  611. 			left -= elen;
    612. 

  612. 			pos += elen;
    613. 

  613. 		}
    614. 

  614. 

  615. 		/* No channel, no luck */
    616. 

  616. 		if (chan_no != -1) {
    617. 

  617. 			struct wiphy *wiphy = priv->wdev->wiphy;
    618. 

  618. 			int freq = ieee80211_channel_to_frequency(chan_no,
    619. 

  619. 							IEEE80211_BAND_2GHZ);
    620. 

  620. 			struct ieee80211_channel *channel =
    621. 

  621. 				ieee80211_get_channel(wiphy, freq);
    622. 

  622. 

  623. 			lbs_deb_scan("scan: %pM, capa %04x, chan %2d, %s, "
    624. 

  624. 				     "%d dBm\n",
    625. 

  625. 				     bssid, capa, chan_no,
    626. 

  626. 				     print_ssid(ssid_buf, ssid, ssid_len),
    627. 

  627. 				     LBS_SCAN_RSSI_TO_MBM(rssi)/100);
    628. 

  628. 

  629. 			if (channel &&
    630. 

  630. 			    !(channel->flags & IEEE80211_CHAN_DISABLED))
    631. 

  631. 				cfg80211_inform_bss(wiphy, channel,
    632. 

  632. 					bssid, le64_to_cpu(*(__le64 *)tsfdesc),
    633. 

  633. 					capa, intvl, ie, ielen,
    634. 

  634. 					LBS_SCAN_RSSI_TO_MBM(rssi),
    635. 

  635. 					GFP_KERNEL);
    636. 

  636. 		} else
    637. 

  637. 			lbs_deb_scan("scan response: missing BSS channel IE\n");
    638. 

  638. 

  639. 		tsfdesc += 8;
    640. 

  640. 	}
    641. 

  641. 	ret = 0;
    642. 

  642. 

  643.  done:
    644. 

  644. 	lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", ret);
    645. 

  645. 	return ret;
    646. 

  646. }
    647. 

  647. 

  648. 

  649. /*
    650. 

  650.  * Our scan command contains a TLV, consting of a SSID TLV, a channel list
    651. 

  651.  * TLV and a rates TLV. Determine the maximum size of them:
    652. 

  652.  */
    653. 

  653. #define LBS_SCAN_MAX_CMD_SIZE			\
    654. 

  654. 	(sizeof(struct cmd_ds_802_11_scan)	\
    655. 

  655. 	 + LBS_MAX_SSID_TLV_SIZE		\
    656. 

  656. 	 + LBS_MAX_CHANNEL_LIST_TLV_SIZE	\
    657. 

  657. 	 + LBS_MAX_RATES_TLV_SIZE)
    658. 

  658. 

  659. /*
    660. 

  660.  * Assumes priv->scan_req is initialized and valid
    661. 

  661.  * Assumes priv->scan_channel is initialized
    662. 

  662.  */
    663. 

  663. static void lbs_scan_worker(struct work_struct *work)
    664. 

  664. {
    665. 

  665. 	struct lbs_private *priv =
    666. 

  666. 		container_of(work, struct lbs_private, scan_work.work);
    667. 

  667. 	struct cmd_ds_802_11_scan *scan_cmd;
    668. 

  668. 	u8 *tlv; /* pointer into our current, growing TLV storage area */
    669. 

  669. 	int last_channel;
    670. 

  670. 	int running, carrier;
    671. 

  671. 

  672. 	lbs_deb_enter(LBS_DEB_SCAN);
    673. 

  673. 

  674. 	scan_cmd = kzalloc(LBS_SCAN_MAX_CMD_SIZE, GFP_KERNEL);
    675. 

  675. 	if (scan_cmd == NULL)
    676. 

  676. 		goto out_no_scan_cmd;
    677. 

  677. 

  678. 	/* prepare fixed part of scan command */
    679. 

  679. 	scan_cmd->bsstype = CMD_BSS_TYPE_ANY;
    680. 

  680. 

  681. 	/* stop network while we're away from our main channel */
    682. 

  682. 	running = !netif_queue_stopped(priv->dev);
    683. 

  683. 	carrier = netif_carrier_ok(priv->dev);
    684. 

  684. 	if (running)
    685. 

  685. 		netif_stop_queue(priv->dev);
    686. 

  686. 	if (carrier)
    687. 

  687. 		netif_carrier_off(priv->dev);
    688. 

  688. 

  689. 	/* prepare fixed part of scan command */
    690. 

  690. 	tlv = scan_cmd->tlvbuffer;
    691. 

  691. 

  692. 	/* add SSID TLV */
    693. 

  693. 	if (priv->scan_req->n_ssids)
    694. 

  694. 		tlv += lbs_add_ssid_tlv(tlv,
    695. 

  695. 					priv->scan_req->ssids[0].ssid,
    696. 

  696. 					priv->scan_req->ssids[0].ssid_len);
    697. 

  697. 

  698. 	/* add channel TLVs */
    699. 

  699. 	last_channel = priv->scan_channel + LBS_SCAN_BEFORE_NAP;
    700. 

  700. 	if (last_channel > priv->scan_req->n_channels)
    701. 

  701. 		last_channel = priv->scan_req->n_channels;
    702. 

  702. 	tlv += lbs_add_channel_list_tlv(priv, tlv, last_channel,
    703. 

  703. 		priv->scan_req->n_ssids);
    704. 

  704. 

  705. 	/* add rates TLV */
    706. 

  706. 	tlv += lbs_add_supported_rates_tlv(tlv);
    707. 

  707. 

  708. 	if (priv->scan_channel < priv->scan_req->n_channels) {
    709. 

  709. 		cancel_delayed_work(&priv->scan_work);
    710. 

  710. 		if (!priv->stopping)
    711. 

  711. 			queue_delayed_work(priv->work_thread, &priv->scan_work,
    712. 

  712. 				msecs_to_jiffies(300));
    713. 

  713. 	}
    714. 

  714. 

  715. 	/* This is the final data we are about to send */
    716. 

  716. 	scan_cmd->hdr.size = cpu_to_le16(tlv - (u8 *)scan_cmd);
    717. 

  717. 	lbs_deb_hex(LBS_DEB_SCAN, "SCAN_CMD", (void *)scan_cmd,
    718. 

  718. 		    sizeof(*scan_cmd));
    719. 

  719. 	lbs_deb_hex(LBS_DEB_SCAN, "SCAN_TLV", scan_cmd->tlvbuffer,
    720. 

  720. 		    tlv - scan_cmd->tlvbuffer);
    721. 

  721. 

  722. 	__lbs_cmd(priv, CMD_802_11_SCAN, &scan_cmd->hdr,
    723. 

  723. 		le16_to_cpu(scan_cmd->hdr.size),
    724. 

  724. 		lbs_ret_scan, 0);
    725. 

  725. 

  726. 	if (priv->scan_channel >= priv->scan_req->n_channels) {
    727. 

  727. 		/* Mark scan done */
    728. 

  728. 		if (priv->internal_scan)
    729. 

  729. 			kfree(priv->scan_req);
    730. 

  730. 		else
    731. 

  731. 			cfg80211_scan_done(priv->scan_req, false);
    732. 

  732. 

  733. 		priv->scan_req = NULL;
    734. 

  734. 		priv->last_scan = jiffies;
    735. 

  735. 	}
    736. 

  736. 

  737. 	/* Restart network */
    738. 

  738. 	if (carrier)
    739. 

  739. 		netif_carrier_on(priv->dev);
    740. 

  740. 	if (running && !priv->tx_pending_len)
    741. 

  741. 		netif_wake_queue(priv->dev);
    742. 

  742. 

  743. 	kfree(scan_cmd);
    744. 

  744. 

  745. 	/* Wake up anything waiting on scan completion */
    746. 

  746. 	if (priv->scan_req == NULL) {
    747. 

  747. 		lbs_deb_scan("scan: waking up waiters\n");
    748. 

  748. 		wake_up_all(&priv->scan_q);
    749. 

  749. 	}
    750. 

  750. 

  751.  out_no_scan_cmd:
    752. 

  752. 	lbs_deb_leave(LBS_DEB_SCAN);
    753. 

  753. }
    754. 

  754. 

  755. static void _internal_start_scan(struct lbs_private *priv, bool internal,
    756. 

  756. 	struct cfg80211_scan_request *request)
    757. 

  757. {
    758. 

  758. 	lbs_deb_enter(LBS_DEB_CFG80211);
    759. 

  759. 

  760. 	lbs_deb_scan("scan: ssids %d, channels %d, ie_len %zd\n",
    761. 

  761. 		request->n_ssids, request->n_channels, request->ie_len);
    762. 

  762. 

  763. 	priv->scan_channel = 0;
    764. 

  764. 	queue_delayed_work(priv->work_thread, &priv->scan_work,
    765. 

  765. 		msecs_to_jiffies(50));
    766. 

  766. 

  767. 	priv->scan_req = request;
    768. 

  768. 	priv->internal_scan = internal;
    769. 

  769. 

  770. 	lbs_deb_leave(LBS_DEB_CFG80211);
    771. 

  771. }
    772. 

  772. 

  773. static int lbs_cfg_scan(struct wiphy *wiphy,
    774. 

  774. 	struct net_device *dev,
    775. 

  775. 	struct cfg80211_scan_request *request)
    776. 

  776. {
    777. 

  777. 	struct lbs_private *priv = wiphy_priv(wiphy);
    778. 

  778. 	int ret = 0;
    779. 

  779. 

  780. 	lbs_deb_enter(LBS_DEB_CFG80211);
    781. 

  781. 

  782. 	if (priv->scan_req || delayed_work_pending(&priv->scan_work)) {
    783. 

  783. 		/* old scan request not yet processed */
    784. 

  784. 		ret = -EAGAIN;
    785. 

  785. 		goto out;
    786. 

  786. 	}
    787. 

  787. 

  788. 	_internal_start_scan(priv, false, request);
    789. 

  789. 

  790. 	if (priv->surpriseremoved)
    791. 

  791. 		ret = -EIO;
    792. 

  792. 

  793.  out:
    794. 

  794. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    795. 

  795. 	return ret;
    796. 

  796. }
    797. 

  797. 

  798. 

  799. 

  800. 

  801. /*
    802. 

  802.  * Events
    803. 

  803.  */
    804. 

  804. 

  805. void lbs_send_disconnect_notification(struct lbs_private *priv)
    806. 

  806. {
    807. 

  807. 	lbs_deb_enter(LBS_DEB_CFG80211);
    808. 

  808. 

  809. 	cfg80211_disconnected(priv->dev,
    810. 

  810. 		0,
    811. 

  811. 		NULL, 0,
    812. 

  812. 		GFP_KERNEL);
    813. 

  813. 

  814. 	lbs_deb_leave(LBS_DEB_CFG80211);
    815. 

  815. }
    816. 

  816. 

  817. void lbs_send_mic_failureevent(struct lbs_private *priv, u32 event)
    818. 

  818. {
    819. 

  819. 	lbs_deb_enter(LBS_DEB_CFG80211);
    820. 

  820. 

  821. 	cfg80211_michael_mic_failure(priv->dev,
    822. 

  822. 		priv->assoc_bss,
    823. 

  823. 		event == MACREG_INT_CODE_MIC_ERR_MULTICAST ?
    824. 

  824. 			NL80211_KEYTYPE_GROUP :
    825. 

  825. 			NL80211_KEYTYPE_PAIRWISE,
    826. 

  826. 		-1,
    827. 

  827. 		NULL,
    828. 

  828. 		GFP_KERNEL);
    829. 

  829. 

  830. 	lbs_deb_leave(LBS_DEB_CFG80211);
    831. 

  831. }
    832. 

  832. 

  833. 

  834. 

  835. 

  836. /*
    837. 

  837.  * Connect/disconnect
    838. 

  838.  */
    839. 

  839. 

  840. 

  841. /*
    842. 

  842.  * This removes all WEP keys
    843. 

  843.  */
    844. 

  844. static int lbs_remove_wep_keys(struct lbs_private *priv)
    845. 

  845. {
    846. 

  846. 	struct cmd_ds_802_11_set_wep cmd;
    847. 

  847. 	int ret;
    848. 

  848. 

  849. 	lbs_deb_enter(LBS_DEB_CFG80211);
    850. 

  850. 

  851. 	memset(&cmd, 0, sizeof(cmd));
    852. 

  852. 	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    853. 

  853. 	cmd.keyindex = cpu_to_le16(priv->wep_tx_key);
    854. 

  854. 	cmd.action = cpu_to_le16(CMD_ACT_REMOVE);
    855. 

  855. 

  856. 	ret = lbs_cmd_with_response(priv, CMD_802_11_SET_WEP, &cmd);
    857. 

  857. 

  858. 	lbs_deb_leave(LBS_DEB_CFG80211);
    859. 

  859. 	return ret;
    860. 

  860. }
    861. 

  861. 

  862. /*
    863. 

  863.  * Set WEP keys
    864. 

  864.  */
    865. 

  865. static int lbs_set_wep_keys(struct lbs_private *priv)
    866. 

  866. {
    867. 

  867. 	struct cmd_ds_802_11_set_wep cmd;
    868. 

  868. 	int i;
    869. 

  869. 	int ret;
    870. 

  870. 

  871. 	lbs_deb_enter(LBS_DEB_CFG80211);
    872. 

  872. 

  873. 	/*
    874. 

  874. 	 * command         13 00
    875. 

  875. 	 * size            50 00
    876. 

  876. 	 * sequence        xx xx
    877. 

  877. 	 * result          00 00
    878. 

  878. 	 * action          02 00     ACT_ADD
    879. 

  879. 	 * transmit key    00 00
    880. 

  880. 	 * type for key 1  01        WEP40
    881. 

  881. 	 * type for key 2  00
    882. 

  882. 	 * type for key 3  00
    883. 

  883. 	 * type for key 4  00
    884. 

  884. 	 * key 1           39 39 39 39 39 00 00 00
    885. 

  885. 	 *                 00 00 00 00 00 00 00 00
    886. 

  886. 	 * key 2           00 00 00 00 00 00 00 00
    887. 

  887. 	 *                 00 00 00 00 00 00 00 00
    888. 

  888. 	 * key 3           00 00 00 00 00 00 00 00
    889. 

  889. 	 *                 00 00 00 00 00 00 00 00
    890. 

  890. 	 * key 4           00 00 00 00 00 00 00 00
    891. 

  891. 	 */
    892. 

  892. 	if (priv->wep_key_len[0] || priv->wep_key_len[1] ||
    893. 

  893. 	    priv->wep_key_len[2] || priv->wep_key_len[3]) {
    894. 

  894. 		/* Only set wep keys if we have at least one of them */
    895. 

  895. 		memset(&cmd, 0, sizeof(cmd));
    896. 

  896. 		cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    897. 

  897. 		cmd.keyindex = cpu_to_le16(priv->wep_tx_key);
    898. 

  898. 		cmd.action = cpu_to_le16(CMD_ACT_ADD);
    899. 

  899. 

  900. 		for (i = 0; i < 4; i++) {
    901. 

  901. 			switch (priv->wep_key_len[i]) {
    902. 

  902. 			case WLAN_KEY_LEN_WEP40:
    903. 

  903. 				cmd.keytype[i] = CMD_TYPE_WEP_40_BIT;
    904. 

  904. 				break;
    905. 

  905. 			case WLAN_KEY_LEN_WEP104:
    906. 

  906. 				cmd.keytype[i] = CMD_TYPE_WEP_104_BIT;
    907. 

  907. 				break;
    908. 

  908. 			default:
    909. 

  909. 				cmd.keytype[i] = 0;
    910. 

  910. 				break;
    911. 

  911. 			}
    912. 

  912. 			memcpy(cmd.keymaterial[i], priv->wep_key[i],
    913. 

  913. 			       priv->wep_key_len[i]);
    914. 

  914. 		}
    915. 

  915. 

  916. 		ret = lbs_cmd_with_response(priv, CMD_802_11_SET_WEP, &cmd);
    917. 

  917. 	} else {
    918. 

  918. 		/* Otherwise remove all wep keys */
    919. 

  919. 		ret = lbs_remove_wep_keys(priv);
    920. 

  920. 	}
    921. 

  921. 

  922. 	lbs_deb_leave(LBS_DEB_CFG80211);
    923. 

  923. 	return ret;
    924. 

  924. }
    925. 

  925. 

  926. 

  927. /*
    928. 

  928.  * Enable/Disable RSN status
    929. 

  929.  */
    930. 

  930. static int lbs_enable_rsn(struct lbs_private *priv, int enable)
    931. 

  931. {
    932. 

  932. 	struct cmd_ds_802_11_enable_rsn cmd;
    933. 

  933. 	int ret;
    934. 

  934. 

  935. 	lbs_deb_enter_args(LBS_DEB_CFG80211, "%d", enable);
    936. 

  936. 

  937. 	/*
    938. 

  938. 	 * cmd       2f 00
    939. 

  939. 	 * size      0c 00
    940. 

  940. 	 * sequence  xx xx
    941. 

  941. 	 * result    00 00
    942. 

  942. 	 * action    01 00    ACT_SET
    943. 

  943. 	 * enable    01 00
    944. 

  944. 	 */
    945. 

  945. 	memset(&cmd, 0, sizeof(cmd));
    946. 

  946. 	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    947. 

  947. 	cmd.action = cpu_to_le16(CMD_ACT_SET);
    948. 

  948. 	cmd.enable = cpu_to_le16(enable);
    949. 

  949. 

  950. 	ret = lbs_cmd_with_response(priv, CMD_802_11_ENABLE_RSN, &cmd);
    951. 

  951. 

  952. 	lbs_deb_leave(LBS_DEB_CFG80211);
    953. 

  953. 	return ret;
    954. 

  954. }
    955. 

  955. 

  956. 

  957. /*
    958. 

  958.  * Set WPA/WPA key material
    959. 

  959.  */
    960. 

  960. 

  961. /*
    962. 

  962.  * like "struct cmd_ds_802_11_key_material", but with cmd_header. Once we
    963. 

  963.  * get rid of WEXT, this should go into host.h
    964. 

  964.  */
    965. 

  965. 

  966. struct cmd_key_material {
    967. 

  967. 	struct cmd_header hdr;
    968. 

  968. 

  969. 	__le16 action;
    970. 

  970. 	struct MrvlIEtype_keyParamSet param;
    971. 

  971. } __packed;
    972. 

  972. 

  973. static int lbs_set_key_material(struct lbs_private *priv,
    974. 

  974. 				int key_type,
    975. 

  975. 				int key_info,
    976. 

  976. 				u8 *key, u16 key_len)
    977. 

  977. {
    978. 

  978. 	struct cmd_key_material cmd;
    979. 

  979. 	int ret;
    980. 

  980. 

  981. 	lbs_deb_enter(LBS_DEB_CFG80211);
    982. 

  982. 

  983. 	/*
    984. 

  984. 	 * Example for WPA (TKIP):
    985. 

  985. 	 *
    986. 

  986. 	 * cmd       5e 00
    987. 

  987. 	 * size      34 00
    988. 

  988. 	 * sequence  xx xx
    989. 

  989. 	 * result    00 00
    990. 

  990. 	 * action    01 00
    991. 

  991. 	 * TLV type  00 01    key param
    992. 

  992. 	 * length    00 26
    993. 

  993. 	 * key type  01 00    TKIP
    994. 

  994. 	 * key info  06 00    UNICAST | ENABLED
    995. 

  995. 	 * key len   20 00
    996. 

  996. 	 * key       32 bytes
    997. 

  997. 	 */
    998. 

  998. 	memset(&cmd, 0, sizeof(cmd));
    999. 

  999. 	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    1000. 

  1000. 	cmd.action = cpu_to_le16(CMD_ACT_SET);
    1001. 

  1001. 	cmd.param.type = cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
    1002. 

  1002. 	cmd.param.length = cpu_to_le16(sizeof(cmd.param) - 4);
    1003. 

  1003. 	cmd.param.keytypeid = cpu_to_le16(key_type);
    1004. 

  1004. 	cmd.param.keyinfo = cpu_to_le16(key_info);
    1005. 

  1005. 	cmd.param.keylen = cpu_to_le16(key_len);
    1006. 

  1006. 	if (key && key_len)
    1007. 

  1007. 		memcpy(cmd.param.key, key, key_len);
    1008. 

  1008. 

  1009. 	ret = lbs_cmd_with_response(priv, CMD_802_11_KEY_MATERIAL, &cmd);
    1010. 

  1010. 

  1011. 	lbs_deb_leave(LBS_DEB_CFG80211);
    1012. 

  1012. 	return ret;
    1013. 

  1013. }
    1014. 

  1014. 

  1015. 

  1016. /*
    1017. 

  1017.  * Sets the auth type (open, shared, etc) in the firmware. That
    1018. 

  1018.  * we use CMD_802_11_AUTHENTICATE is misleading, this firmware
    1019. 

  1019.  * command doesn't send an authentication frame at all, it just
    1020. 

  1020.  * stores the auth_type.
    1021. 

  1021.  */
    1022. 

  1022. static int lbs_set_authtype(struct lbs_private *priv,
    1023. 

  1023. 			    struct cfg80211_connect_params *sme)
    1024. 

  1024. {
    1025. 

  1025. 	struct cmd_ds_802_11_authenticate cmd;
    1026. 

  1026. 	int ret;
    1027. 

  1027. 

  1028. 	lbs_deb_enter_args(LBS_DEB_CFG80211, "%d", sme->auth_type);
    1029. 

  1029. 

  1030. 	/*
    1031. 

  1031. 	 * cmd        11 00
    1032. 

  1032. 	 * size       19 00
    1033. 

  1033. 	 * sequence   xx xx
    1034. 

  1034. 	 * result     00 00
    1035. 

  1035. 	 * BSS id     00 13 19 80 da 30
    1036. 

  1036. 	 * auth type  00
    1037. 

  1037. 	 * reserved   00 00 00 00 00 00 00 00 00 00
    1038. 

  1038. 	 */
    1039. 

  1039. 	memset(&cmd, 0, sizeof(cmd));
    1040. 

  1040. 	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    1041. 

  1041. 	if (sme->bssid)
    1042. 

  1042. 		memcpy(cmd.bssid, sme->bssid, ETH_ALEN);
    1043. 

  1043. 	/* convert auth_type */
    1044. 

  1044. 	ret = lbs_auth_to_authtype(sme->auth_type);
    1045. 

  1045. 	if (ret < 0)
    1046. 

  1046. 		goto done;
    1047. 

  1047. 

  1048. 	cmd.authtype = ret;
    1049. 

  1049. 	ret = lbs_cmd_with_response(priv, CMD_802_11_AUTHENTICATE, &cmd);
    1050. 

  1050. 

  1051.  done:
    1052. 

  1052. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1053. 

  1053. 	return ret;
    1054. 

  1054. }
    1055. 

  1055. 

  1056. 

  1057. /*
    1058. 

  1058.  * Create association request
    1059. 

  1059.  */
    1060. 

  1060. #define LBS_ASSOC_MAX_CMD_SIZE                     \
    1061. 

  1061. 	(sizeof(struct cmd_ds_802_11_associate)    \
    1062. 

  1062. 	 - 512 /* cmd_ds_802_11_associate.iebuf */ \
    1063. 

  1063. 	 + LBS_MAX_SSID_TLV_SIZE                   \
    1064. 

  1064. 	 + LBS_MAX_CHANNEL_TLV_SIZE                \
    1065. 

  1065. 	 + LBS_MAX_CF_PARAM_TLV_SIZE               \
    1066. 

  1066. 	 + LBS_MAX_AUTH_TYPE_TLV_SIZE              \
    1067. 

  1067. 	 + LBS_MAX_WPA_TLV_SIZE)
    1068. 

  1068. 

  1069. static int lbs_associate(struct lbs_private *priv,
    1070. 

  1070. 		struct cfg80211_bss *bss,
    1071. 

  1071. 		struct cfg80211_connect_params *sme)
    1072. 

  1072. {
    1073. 

  1073. 	struct cmd_ds_802_11_associate_response *resp;
    1074. 

  1074. 	struct cmd_ds_802_11_associate *cmd = kzalloc(LBS_ASSOC_MAX_CMD_SIZE,
    1075. 

  1075. 						      GFP_KERNEL);
    1076. 

  1076. 	const u8 *ssid_eid;
    1077. 

  1077. 	size_t len, resp_ie_len;
    1078. 

  1078. 	int status;
    1079. 

  1079. 	int ret;
    1080. 

  1080. 	u8 *pos = &(cmd->iebuf[0]);
    1081. 

  1081. 	u8 *tmp;
    1082. 

  1082. 

  1083. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1084. 

  1084. 

  1085. 	if (!cmd) {
    1086. 

  1086. 		ret = -ENOMEM;
    1087. 

  1087. 		goto done;
    1088. 

  1088. 	}
    1089. 

  1089. 

  1090. 	/*
    1091. 

  1091. 	 * cmd              50 00
    1092. 

  1092. 	 * length           34 00
    1093. 

  1093. 	 * sequence         xx xx
    1094. 

  1094. 	 * result           00 00
    1095. 

  1095. 	 * BSS id           00 13 19 80 da 30
    1096. 

  1096. 	 * capabilities     11 00
    1097. 

  1097. 	 * listen interval  0a 00
    1098. 

  1098. 	 * beacon interval  00 00
    1099. 

  1099. 	 * DTIM period      00
    1100. 

  1100. 	 * TLVs             xx   (up to 512 bytes)
    1101. 

  1101. 	 */
    1102. 

  1102. 	cmd->hdr.command = cpu_to_le16(CMD_802_11_ASSOCIATE);
    1103. 

  1103. 

  1104. 	/* Fill in static fields */
    1105. 

  1105. 	memcpy(cmd->bssid, bss->bssid, ETH_ALEN);
    1106. 

  1106. 	cmd->listeninterval = cpu_to_le16(MRVDRV_DEFAULT_LISTEN_INTERVAL);
    1107. 

  1107. 	cmd->capability = cpu_to_le16(bss->capability);
    1108. 

  1108. 

  1109. 	/* add SSID TLV */
    1110. 

  1110. 	ssid_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
    1111. 

  1111. 	if (ssid_eid)
    1112. 

  1112. 		pos += lbs_add_ssid_tlv(pos, ssid_eid + 2, ssid_eid[1]);
    1113. 

  1113. 	else
    1114. 

  1114. 		lbs_deb_assoc("no SSID\n");
    1115. 

  1115. 

  1116. 	/* add DS param TLV */
    1117. 

  1117. 	if (bss->channel)
    1118. 

  1118. 		pos += lbs_add_channel_tlv(pos, bss->channel->hw_value);
    1119. 

  1119. 	else
    1120. 

  1120. 		lbs_deb_assoc("no channel\n");
    1121. 

  1121. 

  1122. 	/* add (empty) CF param TLV */
    1123. 

  1123. 	pos += lbs_add_cf_param_tlv(pos);
    1124. 

  1124. 

  1125. 	/* add rates TLV */
    1126. 

  1126. 	tmp = pos + 4; /* skip Marvell IE header */
    1127. 

  1127. 	pos += lbs_add_common_rates_tlv(pos, bss);
    1128. 

  1128. 	lbs_deb_hex(LBS_DEB_ASSOC, "Common Rates", tmp, pos - tmp);
    1129. 

  1129. 

  1130. 	/* add auth type TLV */
    1131. 

  1131. 	if (MRVL_FW_MAJOR_REV(priv->fwrelease) >= 9)
    1132. 

  1132. 		pos += lbs_add_auth_type_tlv(pos, sme->auth_type);
    1133. 

  1133. 

  1134. 	/* add WPA/WPA2 TLV */
    1135. 

  1135. 	if (sme->ie && sme->ie_len)
    1136. 

  1136. 		pos += lbs_add_wpa_tlv(pos, sme->ie, sme->ie_len);
    1137. 

  1137. 

  1138. 	len = (sizeof(*cmd) - sizeof(cmd->iebuf)) +
    1139. 

  1139. 		(u16)(pos - (u8 *) &cmd->iebuf);
    1140. 

  1140. 	cmd->hdr.size = cpu_to_le16(len);
    1141. 

  1141. 

  1142. 	lbs_deb_hex(LBS_DEB_ASSOC, "ASSOC_CMD", (u8 *) cmd,
    1143. 

  1143. 			le16_to_cpu(cmd->hdr.size));
    1144. 

  1144. 

  1145. 	/* store for later use */
    1146. 

  1146. 	memcpy(priv->assoc_bss, bss->bssid, ETH_ALEN);
    1147. 

  1147. 

  1148. 	ret = lbs_cmd_with_response(priv, CMD_802_11_ASSOCIATE, cmd);
    1149. 

  1149. 	if (ret)
    1150. 

  1150. 		goto done;
    1151. 

  1151. 

  1152. 	/* generate connect message to cfg80211 */
    1153. 

  1153. 

  1154. 	resp = (void *) cmd; /* recast for easier field access */
    1155. 

  1155. 	status = le16_to_cpu(resp->statuscode);
    1156. 

  1156. 

  1157. 	/* Older FW versions map the IEEE 802.11 Status Code in the association
    1158. 

  1158. 	 * response to the following values returned in resp->statuscode:
    1159. 

  1159. 	 *
    1160. 

  1160. 	 *    IEEE Status Code                Marvell Status Code
    1161. 

  1161. 	 *    0                       ->      0x0000 ASSOC_RESULT_SUCCESS
    1162. 

  1162. 	 *    13                      ->      0x0004 ASSOC_RESULT_AUTH_REFUSED
    1163. 

  1163. 	 *    14                      ->      0x0004 ASSOC_RESULT_AUTH_REFUSED
    1164. 

  1164. 	 *    15                      ->      0x0004 ASSOC_RESULT_AUTH_REFUSED
    1165. 

  1165. 	 *    16                      ->      0x0004 ASSOC_RESULT_AUTH_REFUSED
    1166. 

  1166. 	 *    others                  ->      0x0003 ASSOC_RESULT_REFUSED
    1167. 

  1167. 	 *
    1168. 

  1168. 	 * Other response codes:
    1169. 

  1169. 	 *    0x0001 -> ASSOC_RESULT_INVALID_PARAMETERS (unused)
    1170. 

  1170. 	 *    0x0002 -> ASSOC_RESULT_TIMEOUT (internal timer expired waiting for
    1171. 

  1171. 	 *                                    association response from the AP)
    1172. 

  1172. 	 */
    1173. 

  1173. 	if (MRVL_FW_MAJOR_REV(priv->fwrelease) <= 8) {
    1174. 

  1174. 		switch (status) {
    1175. 

  1175. 		case 0:
    1176. 

  1176. 			break;
    1177. 

  1177. 		case 1:
    1178. 

  1178. 			lbs_deb_assoc("invalid association parameters\n");
    1179. 

  1179. 			status = WLAN_STATUS_CAPS_UNSUPPORTED;
    1180. 

  1180. 			break;
    1181. 

  1181. 		case 2:
    1182. 

  1182. 			lbs_deb_assoc("timer expired while waiting for AP\n");
    1183. 

  1183. 			status = WLAN_STATUS_AUTH_TIMEOUT;
    1184. 

  1184. 			break;
    1185. 

  1185. 		case 3:
    1186. 

  1186. 			lbs_deb_assoc("association refused by AP\n");
    1187. 

  1187. 			status = WLAN_STATUS_ASSOC_DENIED_UNSPEC;
    1188. 

  1188. 			break;
    1189. 

  1189. 		case 4:
    1190. 

  1190. 			lbs_deb_assoc("authentication refused by AP\n");
    1191. 

  1191. 			status = WLAN_STATUS_UNKNOWN_AUTH_TRANSACTION;
    1192. 

  1192. 			break;
    1193. 

  1193. 		default:
    1194. 

  1194. 			lbs_deb_assoc("association failure %d\n", status);
    1195. 

  1195. 			/* v5 OLPC firmware does return the AP status code if
    1196. 

  1196. 			 * it's not one of the values above.  Let that through.
    1197. 

  1197. 			 */
    1198. 

  1198. 			break;
    1199. 

  1199. 		}
    1200. 

  1200. 	}
    1201. 

  1201. 

  1202. 	lbs_deb_assoc("status %d, statuscode 0x%04x, capability 0x%04x, "
    1203. 

  1203. 		      "aid 0x%04x\n", status, le16_to_cpu(resp->statuscode),
    1204. 

  1204. 		      le16_to_cpu(resp->capability), le16_to_cpu(resp->aid));
    1205. 

  1205. 

  1206. 	resp_ie_len = le16_to_cpu(resp->hdr.size)
    1207. 

  1207. 		- sizeof(resp->hdr)
    1208. 

  1208. 		- 6;
    1209. 

  1209. 	cfg80211_connect_result(priv->dev,
    1210. 

  1210. 				priv->assoc_bss,
    1211. 

  1211. 				sme->ie, sme->ie_len,
    1212. 

  1212. 				resp->iebuf, resp_ie_len,
    1213. 

  1213. 				status,
    1214. 

  1214. 				GFP_KERNEL);
    1215. 

  1215. 

  1216. 	if (status == 0) {
    1217. 

  1217. 		/* TODO: get rid of priv->connect_status */
    1218. 

  1218. 		priv->connect_status = LBS_CONNECTED;
    1219. 

  1219. 		netif_carrier_on(priv->dev);
    1220. 

  1220. 		if (!priv->tx_pending_len)
    1221. 

  1221. 			netif_tx_wake_all_queues(priv->dev);
    1222. 

  1222. 	}
    1223. 

  1223. 

  1224. done:
    1225. 

  1225. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1226. 

  1226. 	return ret;
    1227. 

  1227. }
    1228. 

  1228. 

  1229. static struct cfg80211_scan_request *
    1230. 

  1230. _new_connect_scan_req(struct wiphy *wiphy, struct cfg80211_connect_params *sme)
    1231. 

  1231. {
    1232. 

  1232. 	struct cfg80211_scan_request *creq = NULL;
    1233. 

  1233. 	int i, n_channels = 0;
    1234. 

  1234. 	enum ieee80211_band band;
    1235. 

  1235. 

  1236. 	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
    1237. 

  1237. 		if (wiphy->bands[band])
    1238. 

  1238. 			n_channels += wiphy->bands[band]->n_channels;
    1239. 

  1239. 	}
    1240. 

  1240. 

  1241. 	creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
    1242. 

  1242. 		       n_channels * sizeof(void *),
    1243. 

  1243. 		       GFP_ATOMIC);
    1244. 

  1244. 	if (!creq)
    1245. 

  1245. 		return NULL;
    1246. 

  1246. 

  1247. 	/* SSIDs come after channels */
    1248. 

  1248. 	creq->ssids = (void *)&creq->channels[n_channels];
    1249. 

  1249. 	creq->n_channels = n_channels;
    1250. 

  1250. 	creq->n_ssids = 1;
    1251. 

  1251. 

  1252. 	/* Scan all available channels */
    1253. 

  1253. 	i = 0;
    1254. 

  1254. 	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
    1255. 

  1255. 		int j;
    1256. 

  1256. 

  1257. 		if (!wiphy->bands[band])
    1258. 

  1258. 			continue;
    1259. 

  1259. 

  1260. 		for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
    1261. 

  1261. 			/* ignore disabled channels */
    1262. 

  1262. 			if (wiphy->bands[band]->channels[j].flags &
    1263. 

  1263. 						IEEE80211_CHAN_DISABLED)
    1264. 

  1264. 				continue;
    1265. 

  1265. 

  1266. 			creq->channels[i] = &wiphy->bands[band]->channels[j];
    1267. 

  1267. 			i++;
    1268. 

  1268. 		}
    1269. 

  1269. 	}
    1270. 

  1270. 	if (i) {
    1271. 

  1271. 		/* Set real number of channels specified in creq->channels[] */
    1272. 

  1272. 		creq->n_channels = i;
    1273. 

  1273. 

  1274. 		/* Scan for the SSID we're going to connect to */
    1275. 

  1275. 		memcpy(creq->ssids[0].ssid, sme->ssid, sme->ssid_len);
    1276. 

  1276. 		creq->ssids[0].ssid_len = sme->ssid_len;
    1277. 

  1277. 	} else {
    1278. 

  1278. 		/* No channels found... */
    1279. 

  1279. 		kfree(creq);
    1280. 

  1280. 		creq = NULL;
    1281. 

  1281. 	}
    1282. 

  1282. 

  1283. 	return creq;
    1284. 

  1284. }
    1285. 

  1285. 

  1286. static int lbs_cfg_connect(struct wiphy *wiphy, struct net_device *dev,
    1287. 

  1287. 			   struct cfg80211_connect_params *sme)
    1288. 

  1288. {
    1289. 

  1289. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1290. 

  1290. 	struct cfg80211_bss *bss = NULL;
    1291. 

  1291. 	int ret = 0;
    1292. 

  1292. 	u8 preamble = RADIO_PREAMBLE_SHORT;
    1293. 

  1293. 

  1294. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1295. 

  1295. 

  1296. 	if (!sme->bssid) {
    1297. 

  1297. 		/* Run a scan if one isn't in-progress already and if the last
    1298. 

  1298. 		 * scan was done more than 2 seconds ago.
    1299. 

  1299. 		 */
    1300. 

  1300. 		if (priv->scan_req == NULL &&
    1301. 

  1301. 		    time_after(jiffies, priv->last_scan + (2 * HZ))) {
    1302. 

  1302. 			struct cfg80211_scan_request *creq;
    1303. 

  1303. 

  1304. 			creq = _new_connect_scan_req(wiphy, sme);
    1305. 

  1305. 			if (!creq) {
    1306. 

  1306. 				ret = -EINVAL;
    1307. 

  1307. 				goto done;
    1308. 

  1308. 			}
    1309. 

  1309. 

  1310. 			lbs_deb_assoc("assoc: scanning for compatible AP\n");
    1311. 

  1311. 			_internal_start_scan(priv, true, creq);
    1312. 

  1312. 		}
    1313. 

  1313. 

  1314. 		/* Wait for any in-progress scan to complete */
    1315. 

  1315. 		lbs_deb_assoc("assoc: waiting for scan to complete\n");
    1316. 

  1316. 		wait_event_interruptible_timeout(priv->scan_q,
    1317. 

  1317. 						 (priv->scan_req == NULL),
    1318. 

  1318. 						 (15 * HZ));
    1319. 

  1319. 		lbs_deb_assoc("assoc: scanning competed\n");
    1320. 

  1320. 	}
    1321. 

  1321. 

  1322. 	/* Find the BSS we want using available scan results */
    1323. 

  1323. 	bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid,
    1324. 

  1324. 		sme->ssid, sme->ssid_len,
    1325. 

  1325. 		WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
    1326. 

  1326. 	if (!bss) {
    1327. 

  1327. 		wiphy_err(wiphy, "assoc: bss %pM not in scan results\n",
    1328. 

  1328. 			  sme->bssid);
    1329. 

  1329. 		ret = -ENOENT;
    1330. 

  1330. 		goto done;
    1331. 

  1331. 	}
    1332. 

  1332. 	lbs_deb_assoc("trying %pM\n", bss->bssid);
    1333. 

  1333. 	lbs_deb_assoc("cipher 0x%x, key index %d, key len %d\n",
    1334. 

  1334. 		      sme->crypto.cipher_group,
    1335. 

  1335. 		      sme->key_idx, sme->key_len);
    1336. 

  1336. 

  1337. 	/* As this is a new connection, clear locally stored WEP keys */
    1338. 

  1338. 	priv->wep_tx_key = 0;
    1339. 

  1339. 	memset(priv->wep_key, 0, sizeof(priv->wep_key));
    1340. 

  1340. 	memset(priv->wep_key_len, 0, sizeof(priv->wep_key_len));
    1341. 

  1341. 

  1342. 	/* set/remove WEP keys */
    1343. 

  1343. 	switch (sme->crypto.cipher_group) {
    1344. 

  1344. 	case WLAN_CIPHER_SUITE_WEP40:
    1345. 

  1345. 	case WLAN_CIPHER_SUITE_WEP104:
    1346. 

  1346. 		/* Store provided WEP keys in priv-> */
    1347. 

  1347. 		priv->wep_tx_key = sme->key_idx;
    1348. 

  1348. 		priv->wep_key_len[sme->key_idx] = sme->key_len;
    1349. 

  1349. 		memcpy(priv->wep_key[sme->key_idx], sme->key, sme->key_len);
    1350. 

  1350. 		/* Set WEP keys and WEP mode */
    1351. 

  1351. 		lbs_set_wep_keys(priv);
    1352. 

  1352. 		priv->mac_control |= CMD_ACT_MAC_WEP_ENABLE;
    1353. 

  1353. 		lbs_set_mac_control(priv);
    1354. 

  1354. 		/* No RSN mode for WEP */
    1355. 

  1355. 		lbs_enable_rsn(priv, 0);
    1356. 

  1356. 		break;
    1357. 

  1357. 	case 0: /* there's no WLAN_CIPHER_SUITE_NONE definition */
    1358. 

  1358. 		/*
    1359. 

  1359. 		 * If we don't have no WEP, no WPA and no WPA2,
    1360. 

  1360. 		 * we remove all keys like in the WPA/WPA2 setup,
    1361. 

  1361. 		 * we just don't set RSN.
    1362. 

  1362. 		 *
    1363. 

  1363. 		 * Therefore: fall-through
    1364. 

  1364. 		 */
    1365. 

  1365. 	case WLAN_CIPHER_SUITE_TKIP:
    1366. 

  1366. 	case WLAN_CIPHER_SUITE_CCMP:
    1367. 

  1367. 		/* Remove WEP keys and WEP mode */
    1368. 

  1368. 		lbs_remove_wep_keys(priv);
    1369. 

  1369. 		priv->mac_control &= ~CMD_ACT_MAC_WEP_ENABLE;
    1370. 

  1370. 		lbs_set_mac_control(priv);
    1371. 

  1371. 

  1372. 		/* clear the WPA/WPA2 keys */
    1373. 

  1373. 		lbs_set_key_material(priv,
    1374. 

  1374. 			KEY_TYPE_ID_WEP, /* doesn't matter */
    1375. 

  1375. 			KEY_INFO_WPA_UNICAST,
    1376. 

  1376. 			NULL, 0);
    1377. 

  1377. 		lbs_set_key_material(priv,
    1378. 

  1378. 			KEY_TYPE_ID_WEP, /* doesn't matter */
    1379. 

  1379. 			KEY_INFO_WPA_MCAST,
    1380. 

  1380. 			NULL, 0);
    1381. 

  1381. 		/* RSN mode for WPA/WPA2 */
    1382. 

  1382. 		lbs_enable_rsn(priv, sme->crypto.cipher_group != 0);
    1383. 

  1383. 		break;
    1384. 

  1384. 	default:
    1385. 

  1385. 		wiphy_err(wiphy, "unsupported cipher group 0x%x\n",
    1386. 

  1386. 			  sme->crypto.cipher_group);
    1387. 

  1387. 		ret = -ENOTSUPP;
    1388. 

  1388. 		goto done;
    1389. 

  1389. 	}
    1390. 

  1390. 

  1391. 	lbs_set_authtype(priv, sme);
    1392. 

  1392. 	lbs_set_radio(priv, preamble, 1);
    1393. 

  1393. 

  1394. 	/* Do the actual association */
    1395. 

  1395. 	ret = lbs_associate(priv, bss, sme);
    1396. 

  1396. 

  1397.  done:
    1398. 

  1398. 	if (bss)
    1399. 

  1399. 		cfg80211_put_bss(bss);
    1400. 

  1400. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1401. 

  1401. 	return ret;
    1402. 

  1402. }
    1403. 

  1403. 

  1404. static int lbs_cfg_disconnect(struct wiphy *wiphy, struct net_device *dev,
    1405. 

  1405. 	u16 reason_code)
    1406. 

  1406. {
    1407. 

  1407. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1408. 

  1408. 	struct cmd_ds_802_11_deauthenticate cmd;
    1409. 

  1409. 

  1410. 	lbs_deb_enter_args(LBS_DEB_CFG80211, "reason_code %d", reason_code);
    1411. 

  1411. 

  1412. 	/* store for lbs_cfg_ret_disconnect() */
    1413. 

  1413. 	priv->disassoc_reason = reason_code;
    1414. 

  1414. 

  1415. 	memset(&cmd, 0, sizeof(cmd));
    1416. 

  1416. 	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    1417. 

  1417. 	/* Mildly ugly to use a locally store my own BSSID ... */
    1418. 

  1418. 	memcpy(cmd.macaddr, &priv->assoc_bss, ETH_ALEN);
    1419. 

  1419. 	cmd.reasoncode = cpu_to_le16(reason_code);
    1420. 

  1420. 

  1421. 	if (lbs_cmd_with_response(priv, CMD_802_11_DEAUTHENTICATE, &cmd))
    1422. 

  1422. 		return -EFAULT;
    1423. 

  1423. 

  1424. 	cfg80211_disconnected(priv->dev,
    1425. 

  1425. 			priv->disassoc_reason,
    1426. 

  1426. 			NULL, 0,
    1427. 

  1427. 			GFP_KERNEL);
    1428. 

  1428. 	priv->connect_status = LBS_DISCONNECTED;
    1429. 

  1429. 

  1430. 	return 0;
    1431. 

  1431. }
    1432. 

  1432. 

  1433. 

  1434. static int lbs_cfg_set_default_key(struct wiphy *wiphy,
    1435. 

  1435. 				   struct net_device *netdev,
    1436. 

  1436. 				   u8 key_index, bool unicast,
    1437. 

  1437. 				   bool multicast)
    1438. 

  1438. {
    1439. 

  1439. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1440. 

  1440. 

  1441. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1442. 

  1442. 

  1443. 	if (key_index != priv->wep_tx_key) {
    1444. 

  1444. 		lbs_deb_assoc("set_default_key: to %d\n", key_index);
    1445. 

  1445. 		priv->wep_tx_key = key_index;
    1446. 

  1446. 		lbs_set_wep_keys(priv);
    1447. 

  1447. 	}
    1448. 

  1448. 

  1449. 	return 0;
    1450. 

  1450. }
    1451. 

  1451. 

  1452. 

  1453. static int lbs_cfg_add_key(struct wiphy *wiphy, struct net_device *netdev,
    1454. 

  1454. 			   u8 idx, bool pairwise, const u8 *mac_addr,
    1455. 

  1455. 			   struct key_params *params)
    1456. 

  1456. {
    1457. 

  1457. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1458. 

  1458. 	u16 key_info;
    1459. 

  1459. 	u16 key_type;
    1460. 

  1460. 	int ret = 0;
    1461. 

  1461. 

  1462. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1463. 

  1463. 

  1464. 	lbs_deb_assoc("add_key: cipher 0x%x, mac_addr %pM\n",
    1465. 

  1465. 		      params->cipher, mac_addr);
    1466. 

  1466. 	lbs_deb_assoc("add_key: key index %d, key len %d\n",
    1467. 

  1467. 		      idx, params->key_len);
    1468. 

  1468. 	if (params->key_len)
    1469. 

  1469. 		lbs_deb_hex(LBS_DEB_CFG80211, "KEY",
    1470. 

  1470. 			    params->key, params->key_len);
    1471. 

  1471. 

  1472. 	lbs_deb_assoc("add_key: seq len %d\n", params->seq_len);
    1473. 

  1473. 	if (params->seq_len)
    1474. 

  1474. 		lbs_deb_hex(LBS_DEB_CFG80211, "SEQ",
    1475. 

  1475. 			    params->seq, params->seq_len);
    1476. 

  1476. 

  1477. 	switch (params->cipher) {
    1478. 

  1478. 	case WLAN_CIPHER_SUITE_WEP40:
    1479. 

  1479. 	case WLAN_CIPHER_SUITE_WEP104:
    1480. 

  1480. 		/* actually compare if something has changed ... */
    1481. 

  1481. 		if ((priv->wep_key_len[idx] != params->key_len) ||
    1482. 

  1482. 			memcmp(priv->wep_key[idx],
    1483. 

  1483. 			       params->key, params->key_len) != 0) {
    1484. 

  1484. 			priv->wep_key_len[idx] = params->key_len;
    1485. 

  1485. 			memcpy(priv->wep_key[idx],
    1486. 

  1486. 			       params->key, params->key_len);
    1487. 

  1487. 			lbs_set_wep_keys(priv);
    1488. 

  1488. 		}
    1489. 

  1489. 		break;
    1490. 

  1490. 	case WLAN_CIPHER_SUITE_TKIP:
    1491. 

  1491. 	case WLAN_CIPHER_SUITE_CCMP:
    1492. 

  1492. 		key_info = KEY_INFO_WPA_ENABLED | ((idx == 0)
    1493. 

  1493. 						   ? KEY_INFO_WPA_UNICAST
    1494. 

  1494. 						   : KEY_INFO_WPA_MCAST);
    1495. 

  1495. 		key_type = (params->cipher == WLAN_CIPHER_SUITE_TKIP)
    1496. 

  1496. 			? KEY_TYPE_ID_TKIP
    1497. 

  1497. 			: KEY_TYPE_ID_AES;
    1498. 

  1498. 		lbs_set_key_material(priv,
    1499. 

  1499. 				     key_type,
    1500. 

  1500. 				     key_info,
    1501. 

  1501. 				     params->key, params->key_len);
    1502. 

  1502. 		break;
    1503. 

  1503. 	default:
    1504. 

  1504. 		wiphy_err(wiphy, "unhandled cipher 0x%x\n", params->cipher);
    1505. 

  1505. 		ret = -ENOTSUPP;
    1506. 

  1506. 		break;
    1507. 

  1507. 	}
    1508. 

  1508. 

  1509. 	return ret;
    1510. 

  1510. }
    1511. 

  1511. 

  1512. 

  1513. static int lbs_cfg_del_key(struct wiphy *wiphy, struct net_device *netdev,
    1514. 

  1514. 			   u8 key_index, bool pairwise, const u8 *mac_addr)
    1515. 

  1515. {
    1516. 

  1516. 

  1517. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1518. 

  1518. 

  1519. 	lbs_deb_assoc("del_key: key_idx %d, mac_addr %pM\n",
    1520. 

  1520. 		      key_index, mac_addr);
    1521. 

  1521. 

  1522. #ifdef TODO
    1523. 

  1523. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1524. 

  1524. 	/*
    1525. 

  1525. 	 * I think can keep this a NO-OP, because:
    1526. 

    1527. 

  1527. 	 * - we clear all keys whenever we do lbs_cfg_connect() anyway
    1528. 

  1528. 	 * - neither "iw" nor "wpa_supplicant" won't call this during
    1529. 

  1529. 	 *   an ongoing connection
    1530. 

  1530. 	 * - TODO: but I have to check if this is still true when
    1531. 

  1531. 	 *   I set the AP to periodic re-keying
    1532. 

  1532. 	 * - we've not kzallec() something when we've added a key at
    1533. 

  1533. 	 *   lbs_cfg_connect() or lbs_cfg_add_key().
    1534. 

  1534. 	 *
    1535. 

  1535. 	 * This causes lbs_cfg_del_key() only called at disconnect time,
    1536. 

  1536. 	 * where we'd just waste time deleting a key that is not going
    1537. 

  1537. 	 * to be used anyway.
    1538. 

  1538. 	 */
    1539. 

  1539. 	if (key_index < 3 && priv->wep_key_len[key_index]) {
    1540. 

  1540. 		priv->wep_key_len[key_index] = 0;
    1541. 

  1541. 		lbs_set_wep_keys(priv);
    1542. 

  1542. 	}
    1543. 

  1543. #endif
    1544. 

  1544. 

  1545. 	return 0;
    1546. 

  1546. }
    1547. 

  1547. 

  1548. 

  1549. /*
    1550. 

  1550.  * Get station
    1551. 

  1551.  */
    1552. 

  1552. 

  1553. static int lbs_cfg_get_station(struct wiphy *wiphy, struct net_device *dev,
    1554. 

  1554. 			      u8 *mac, struct station_info *sinfo)
    1555. 

  1555. {
    1556. 

  1556. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1557. 

  1557. 	s8 signal, noise;
    1558. 

  1558. 	int ret;
    1559. 

  1559. 	size_t i;
    1560. 

  1560. 

  1561. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1562. 

  1562. 

  1563. 	sinfo->filled |= STATION_INFO_TX_BYTES |
    1564. 

  1564. 			 STATION_INFO_TX_PACKETS |
    1565. 

  1565. 			 STATION_INFO_RX_BYTES |
    1566. 

  1566. 			 STATION_INFO_RX_PACKETS;
    1567. 

  1567. 	sinfo->tx_bytes = priv->dev->stats.tx_bytes;
    1568. 

  1568. 	sinfo->tx_packets = priv->dev->stats.tx_packets;
    1569. 

  1569. 	sinfo->rx_bytes = priv->dev->stats.rx_bytes;
    1570. 

  1570. 	sinfo->rx_packets = priv->dev->stats.rx_packets;
    1571. 

  1571. 

  1572. 	/* Get current RSSI */
    1573. 

  1573. 	ret = lbs_get_rssi(priv, &signal, &noise);
    1574. 

  1574. 	if (ret == 0) {
    1575. 

  1575. 		sinfo->signal = signal;
    1576. 

  1576. 		sinfo->filled |= STATION_INFO_SIGNAL;
    1577. 

  1577. 	}
    1578. 

  1578. 

  1579. 	/* Convert priv->cur_rate from hw_value to NL80211 value */
    1580. 

  1580. 	for (i = 0; i < ARRAY_SIZE(lbs_rates); i++) {
    1581. 

  1581. 		if (priv->cur_rate == lbs_rates[i].hw_value) {
    1582. 

  1582. 			sinfo->txrate.legacy = lbs_rates[i].bitrate;
    1583. 

  1583. 			sinfo->filled |= STATION_INFO_TX_BITRATE;
    1584. 

  1584. 			break;
    1585. 

  1585. 		}
    1586. 

  1586. 	}
    1587. 

  1587. 

  1588. 	return 0;
    1589. 

  1589. }
    1590. 

  1590. 

  1591. 

  1592. 

  1593. 

  1594. /*
    1595. 

  1595.  * "Site survey", here just current channel and noise level
    1596. 

  1596.  */
    1597. 

  1597. 

  1598. static int lbs_get_survey(struct wiphy *wiphy, struct net_device *dev,
    1599. 

  1599. 	int idx, struct survey_info *survey)
    1600. 

  1600. {
    1601. 

  1601. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1602. 

  1602. 	s8 signal, noise;
    1603. 

  1603. 	int ret;
    1604. 

  1604. 

  1605. 	if (idx != 0)
    1606. 

  1606. 		ret = -ENOENT;
    1607. 

  1607. 

  1608. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1609. 

  1609. 

  1610. 	survey->channel = ieee80211_get_channel(wiphy,
    1611. 

  1611. 		ieee80211_channel_to_frequency(priv->channel,
    1612. 

  1612. 					       IEEE80211_BAND_2GHZ));
    1613. 

  1613. 

  1614. 	ret = lbs_get_rssi(priv, &signal, &noise);
    1615. 

  1615. 	if (ret == 0) {
    1616. 

  1616. 		survey->filled = SURVEY_INFO_NOISE_DBM;
    1617. 

  1617. 		survey->noise = noise;
    1618. 

  1618. 	}
    1619. 

  1619. 

  1620. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1621. 

  1621. 	return ret;
    1622. 

  1622. }
    1623. 

  1623. 

  1624. 

  1625. 

  1626. 

  1627. /*
    1628. 

  1628.  * Change interface
    1629. 

  1629.  */
    1630. 

  1630. 

  1631. static int lbs_change_intf(struct wiphy *wiphy, struct net_device *dev,
    1632. 

  1632. 	enum nl80211_iftype type, u32 *flags,
    1633. 

  1633. 	       struct vif_params *params)
    1634. 

  1634. {
    1635. 

  1635. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1636. 

  1636. 	int ret = 0;
    1637. 

  1637. 

  1638. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1639. 

  1639. 

  1640. 	switch (type) {
    1641. 

  1641. 	case NL80211_IFTYPE_MONITOR:
    1642. 

  1642. 		ret = lbs_set_monitor_mode(priv, 1);
    1643. 

  1643. 		break;
    1644. 

  1644. 	case NL80211_IFTYPE_STATION:
    1645. 

  1645. 		if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR)
    1646. 

  1646. 			ret = lbs_set_monitor_mode(priv, 0);
    1647. 

  1647. 		if (!ret)
    1648. 

  1648. 			ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 1);
    1649. 

  1649. 		break;
    1650. 

  1650. 	case NL80211_IFTYPE_ADHOC:
    1651. 

  1651. 		if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR)
    1652. 

  1652. 			ret = lbs_set_monitor_mode(priv, 0);
    1653. 

  1653. 		if (!ret)
    1654. 

  1654. 			ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 2);
    1655. 

  1655. 		break;
    1656. 

  1656. 	default:
    1657. 

  1657. 		ret = -ENOTSUPP;
    1658. 

  1658. 	}
    1659. 

  1659. 

  1660. 	if (!ret)
    1661. 

  1661. 		priv->wdev->iftype = type;
    1662. 

  1662. 

  1663. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1664. 

  1664. 	return ret;
    1665. 

  1665. }
    1666. 

  1666. 

  1667. 

  1668. 

  1669. /*
    1670. 

  1670.  * IBSS (Ad-Hoc)
    1671. 

  1671.  */
    1672. 

  1672. 

  1673. /*
    1674. 

  1674.  * The firmware needs the following bits masked out of the beacon-derived
    1675. 

  1675.  * capability field when associating/joining to a BSS:
    1676. 

  1676.  *  9 (QoS), 11 (APSD), 12 (unused), 14 (unused), 15 (unused)
    1677. 

  1677.  */
    1678. 

  1678. #define CAPINFO_MASK (~(0xda00))
    1679. 

  1679. 

  1680. 

  1681. static void lbs_join_post(struct lbs_private *priv,
    1682. 

  1682. 			  struct cfg80211_ibss_params *params,
    1683. 

  1683. 			  u8 *bssid, u16 capability)
    1684. 

  1684. {
    1685. 

  1685. 	u8 fake_ie[2 + IEEE80211_MAX_SSID_LEN + /* ssid */
    1686. 

  1686. 		   2 + 4 +                      /* basic rates */
    1687. 

  1687. 		   2 + 1 +                      /* DS parameter */
    1688. 

  1688. 		   2 + 2 +                      /* atim */
    1689. 

  1689. 		   2 + 8];                      /* extended rates */
    1690. 

  1690. 	u8 *fake = fake_ie;
    1691. 

  1691. 

  1692. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1693. 

  1693. 

  1694. 	/*
    1695. 

  1695. 	 * For cfg80211_inform_bss, we'll need a fake IE, as we can't get
    1696. 

  1696. 	 * the real IE from the firmware. So we fabricate a fake IE based on
    1697. 

  1697. 	 * what the firmware actually sends (sniffed with wireshark).
    1698. 

  1698. 	 */
    1699. 

  1699. 	/* Fake SSID IE */
    1700. 

  1700. 	*fake++ = WLAN_EID_SSID;
    1701. 

  1701. 	*fake++ = params->ssid_len;
    1702. 

  1702. 	memcpy(fake, params->ssid, params->ssid_len);
    1703. 

  1703. 	fake += params->ssid_len;
    1704. 

  1704. 	/* Fake supported basic rates IE */
    1705. 

  1705. 	*fake++ = WLAN_EID_SUPP_RATES;
    1706. 

  1706. 	*fake++ = 4;
    1707. 

  1707. 	*fake++ = 0x82;
    1708. 

  1708. 	*fake++ = 0x84;
    1709. 

  1709. 	*fake++ = 0x8b;
    1710. 

  1710. 	*fake++ = 0x96;
    1711. 

  1711. 	/* Fake DS channel IE */
    1712. 

  1712. 	*fake++ = WLAN_EID_DS_PARAMS;
    1713. 

  1713. 	*fake++ = 1;
    1714. 

  1714. 	*fake++ = params->channel->hw_value;
    1715. 

  1715. 	/* Fake IBSS params IE */
    1716. 

  1716. 	*fake++ = WLAN_EID_IBSS_PARAMS;
    1717. 

  1717. 	*fake++ = 2;
    1718. 

  1718. 	*fake++ = 0; /* ATIM=0 */
    1719. 

  1719. 	*fake++ = 0;
    1720. 

  1720. 	/* Fake extended rates IE, TODO: don't add this for 802.11b only,
    1721. 

  1721. 	 * but I don't know how this could be checked */
    1722. 

  1722. 	*fake++ = WLAN_EID_EXT_SUPP_RATES;
    1723. 

  1723. 	*fake++ = 8;
    1724. 

  1724. 	*fake++ = 0x0c;
    1725. 

  1725. 	*fake++ = 0x12;
    1726. 

  1726. 	*fake++ = 0x18;
    1727. 

  1727. 	*fake++ = 0x24;
    1728. 

  1728. 	*fake++ = 0x30;
    1729. 

  1729. 	*fake++ = 0x48;
    1730. 

  1730. 	*fake++ = 0x60;
    1731. 

  1731. 	*fake++ = 0x6c;
    1732. 

  1732. 	lbs_deb_hex(LBS_DEB_CFG80211, "IE", fake_ie, fake - fake_ie);
    1733. 

  1733. 

  1734. 	cfg80211_inform_bss(priv->wdev->wiphy,
    1735. 

  1735. 			    params->channel,
    1736. 

  1736. 			    bssid,
    1737. 

  1737. 			    0,
    1738. 

  1738. 			    capability,
    1739. 

  1739. 			    params->beacon_interval,
    1740. 

  1740. 			    fake_ie, fake - fake_ie,
    1741. 

  1741. 			    0, GFP_KERNEL);
    1742. 

  1742. 

  1743. 	memcpy(priv->wdev->ssid, params->ssid, params->ssid_len);
    1744. 

  1744. 	priv->wdev->ssid_len = params->ssid_len;
    1745. 

  1745. 

  1746. 	cfg80211_ibss_joined(priv->dev, bssid, GFP_KERNEL);
    1747. 

  1747. 

  1748. 	/* TODO: consider doing this at MACREG_INT_CODE_LINK_SENSED time */
    1749. 

  1749. 	priv->connect_status = LBS_CONNECTED;
    1750. 

  1750. 	netif_carrier_on(priv->dev);
    1751. 

  1751. 	if (!priv->tx_pending_len)
    1752. 

  1752. 		netif_wake_queue(priv->dev);
    1753. 

  1753. 

  1754. 	lbs_deb_leave(LBS_DEB_CFG80211);
    1755. 

  1755. }
    1756. 

  1756. 

  1757. static int lbs_ibss_join_existing(struct lbs_private *priv,
    1758. 

  1758. 	struct cfg80211_ibss_params *params,
    1759. 

  1759. 	struct cfg80211_bss *bss)
    1760. 

  1760. {
    1761. 

  1761. 	const u8 *rates_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SUPP_RATES);
    1762. 

  1762. 	struct cmd_ds_802_11_ad_hoc_join cmd;
    1763. 

  1763. 	u8 preamble = RADIO_PREAMBLE_SHORT;
    1764. 

  1764. 	int ret = 0;
    1765. 

  1765. 

  1766. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1767. 

  1767. 

  1768. 	/* TODO: set preamble based on scan result */
    1769. 

  1769. 	ret = lbs_set_radio(priv, preamble, 1);
    1770. 

  1770. 	if (ret)
    1771. 

  1771. 		goto out;
    1772. 

  1772. 

  1773. 	/*
    1774. 

  1774. 	 * Example CMD_802_11_AD_HOC_JOIN command:
    1775. 

  1775. 	 *
    1776. 

  1776. 	 * command         2c 00         CMD_802_11_AD_HOC_JOIN
    1777. 

  1777. 	 * size            65 00
    1778. 

  1778. 	 * sequence        xx xx
    1779. 

  1779. 	 * result          00 00
    1780. 

  1780. 	 * bssid           02 27 27 97 2f 96
    1781. 

  1781. 	 * ssid            49 42 53 53 00 00 00 00
    1782. 

  1782. 	 *                 00 00 00 00 00 00 00 00
    1783. 

  1783. 	 *                 00 00 00 00 00 00 00 00
    1784. 

  1784. 	 *                 00 00 00 00 00 00 00 00
    1785. 

  1785. 	 * type            02            CMD_BSS_TYPE_IBSS
    1786. 

  1786. 	 * beacon period   64 00
    1787. 

  1787. 	 * dtim period     00
    1788. 

  1788. 	 * timestamp       00 00 00 00 00 00 00 00
    1789. 

  1789. 	 * localtime       00 00 00 00 00 00 00 00
    1790. 

  1790. 	 * IE DS           03
    1791. 

  1791. 	 * IE DS len       01
    1792. 

  1792. 	 * IE DS channel   01
    1793. 

  1793. 	 * reserveed       00 00 00 00
    1794. 

  1794. 	 * IE IBSS         06
    1795. 

  1795. 	 * IE IBSS len     02
    1796. 

  1796. 	 * IE IBSS atim    00 00
    1797. 

  1797. 	 * reserved        00 00 00 00
    1798. 

  1798. 	 * capability      02 00
    1799. 

  1799. 	 * rates           82 84 8b 96 0c 12 18 24 30 48 60 6c 00
    1800. 

  1800. 	 * fail timeout    ff 00
    1801. 

  1801. 	 * probe delay     00 00
    1802. 

  1802. 	 */
    1803. 

  1803. 	memset(&cmd, 0, sizeof(cmd));
    1804. 

  1804. 	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    1805. 

  1805. 

  1806. 	memcpy(cmd.bss.bssid, bss->bssid, ETH_ALEN);
    1807. 

  1807. 	memcpy(cmd.bss.ssid, params->ssid, params->ssid_len);
    1808. 

  1808. 	cmd.bss.type = CMD_BSS_TYPE_IBSS;
    1809. 

  1809. 	cmd.bss.beaconperiod = cpu_to_le16(params->beacon_interval);
    1810. 

  1810. 	cmd.bss.ds.header.id = WLAN_EID_DS_PARAMS;
    1811. 

  1811. 	cmd.bss.ds.header.len = 1;
    1812. 

  1812. 	cmd.bss.ds.channel = params->channel->hw_value;
    1813. 

  1813. 	cmd.bss.ibss.header.id = WLAN_EID_IBSS_PARAMS;
    1814. 

  1814. 	cmd.bss.ibss.header.len = 2;
    1815. 

  1815. 	cmd.bss.ibss.atimwindow = 0;
    1816. 

  1816. 	cmd.bss.capability = cpu_to_le16(bss->capability & CAPINFO_MASK);
    1817. 

  1817. 

  1818. 	/* set rates to the intersection of our rates and the rates in the
    1819. 

  1819. 	   bss */
    1820. 

  1820. 	if (!rates_eid) {
    1821. 

  1821. 		lbs_add_rates(cmd.bss.rates);
    1822. 

  1822. 	} else {
    1823. 

  1823. 		int hw, i;
    1824. 

  1824. 		u8 rates_max = rates_eid[1];
    1825. 

  1825. 		u8 *rates = cmd.bss.rates;
    1826. 

  1826. 		for (hw = 0; hw < ARRAY_SIZE(lbs_rates); hw++) {
    1827. 

  1827. 			u8 hw_rate = lbs_rates[hw].bitrate / 5;
    1828. 

  1828. 			for (i = 0; i < rates_max; i++) {
    1829. 

  1829. 				if (hw_rate == (rates_eid[i+2] & 0x7f)) {
    1830. 

  1830. 					u8 rate = rates_eid[i+2];
    1831. 

  1831. 					if (rate == 0x02 || rate == 0x04 ||
    1832. 

  1832. 					    rate == 0x0b || rate == 0x16)
    1833. 

  1833. 						rate |= 0x80;
    1834. 

  1834. 					*rates++ = rate;
    1835. 

  1835. 				}
    1836. 

  1836. 			}
    1837. 

  1837. 		}
    1838. 

  1838. 	}
    1839. 

  1839. 

  1840. 	/* Only v8 and below support setting this */
    1841. 

  1841. 	if (MRVL_FW_MAJOR_REV(priv->fwrelease) <= 8) {
    1842. 

  1842. 		cmd.failtimeout = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT);
    1843. 

  1843. 		cmd.probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
    1844. 

  1844. 	}
    1845. 

  1845. 	ret = lbs_cmd_with_response(priv, CMD_802_11_AD_HOC_JOIN, &cmd);
    1846. 

  1846. 	if (ret)
    1847. 

  1847. 		goto out;
    1848. 

  1848. 

  1849. 	/*
    1850. 

  1850. 	 * This is a sample response to CMD_802_11_AD_HOC_JOIN:
    1851. 

  1851. 	 *
    1852. 

  1852. 	 * response        2c 80
    1853. 

  1853. 	 * size            09 00
    1854. 

  1854. 	 * sequence        xx xx
    1855. 

  1855. 	 * result          00 00
    1856. 

  1856. 	 * reserved        00
    1857. 

  1857. 	 */
    1858. 

  1858. 	lbs_join_post(priv, params, bss->bssid, bss->capability);
    1859. 

  1859. 

  1860.  out:
    1861. 

  1861. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1862. 

  1862. 	return ret;
    1863. 

  1863. }
    1864. 

  1864. 

  1865. 

  1866. 

  1867. static int lbs_ibss_start_new(struct lbs_private *priv,
    1868. 

  1868. 	struct cfg80211_ibss_params *params)
    1869. 

  1869. {
    1870. 

  1870. 	struct cmd_ds_802_11_ad_hoc_start cmd;
    1871. 

  1871. 	struct cmd_ds_802_11_ad_hoc_result *resp =
    1872. 

  1872. 		(struct cmd_ds_802_11_ad_hoc_result *) &cmd;
    1873. 

  1873. 	u8 preamble = RADIO_PREAMBLE_SHORT;
    1874. 

  1874. 	int ret = 0;
    1875. 

  1875. 	u16 capability;
    1876. 

  1876. 

  1877. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1878. 

  1878. 

  1879. 	ret = lbs_set_radio(priv, preamble, 1);
    1880. 

  1880. 	if (ret)
    1881. 

  1881. 		goto out;
    1882. 

  1882. 

  1883. 	/*
    1884. 

  1884. 	 * Example CMD_802_11_AD_HOC_START command:
    1885. 

  1885. 	 *
    1886. 

  1886. 	 * command         2b 00         CMD_802_11_AD_HOC_START
    1887. 

  1887. 	 * size            b1 00
    1888. 

  1888. 	 * sequence        xx xx
    1889. 

  1889. 	 * result          00 00
    1890. 

  1890. 	 * ssid            54 45 53 54 00 00 00 00
    1891. 

  1891. 	 *                 00 00 00 00 00 00 00 00
    1892. 

  1892. 	 *                 00 00 00 00 00 00 00 00
    1893. 

  1893. 	 *                 00 00 00 00 00 00 00 00
    1894. 

  1894. 	 * bss type        02
    1895. 

  1895. 	 * beacon period   64 00
    1896. 

  1896. 	 * dtim period     00
    1897. 

  1897. 	 * IE IBSS         06
    1898. 

  1898. 	 * IE IBSS len     02
    1899. 

  1899. 	 * IE IBSS atim    00 00
    1900. 

  1900. 	 * reserved        00 00 00 00
    1901. 

  1901. 	 * IE DS           03
    1902. 

  1902. 	 * IE DS len       01
    1903. 

  1903. 	 * IE DS channel   01
    1904. 

  1904. 	 * reserved        00 00 00 00
    1905. 

  1905. 	 * probe delay     00 00
    1906. 

  1906. 	 * capability      02 00
    1907. 

  1907. 	 * rates           82 84 8b 96   (basic rates with have bit 7 set)
    1908. 

  1908. 	 *                 0c 12 18 24 30 48 60 6c
    1909. 

  1909. 	 * padding         100 bytes
    1910. 

  1910. 	 */
    1911. 

  1911. 	memset(&cmd, 0, sizeof(cmd));
    1912. 

  1912. 	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
    1913. 

  1913. 	memcpy(cmd.ssid, params->ssid, params->ssid_len);
    1914. 

  1914. 	cmd.bsstype = CMD_BSS_TYPE_IBSS;
    1915. 

  1915. 	cmd.beaconperiod = cpu_to_le16(params->beacon_interval);
    1916. 

  1916. 	cmd.ibss.header.id = WLAN_EID_IBSS_PARAMS;
    1917. 

  1917. 	cmd.ibss.header.len = 2;
    1918. 

  1918. 	cmd.ibss.atimwindow = 0;
    1919. 

  1919. 	cmd.ds.header.id = WLAN_EID_DS_PARAMS;
    1920. 

  1920. 	cmd.ds.header.len = 1;
    1921. 

  1921. 	cmd.ds.channel = params->channel->hw_value;
    1922. 

  1922. 	/* Only v8 and below support setting probe delay */
    1923. 

  1923. 	if (MRVL_FW_MAJOR_REV(priv->fwrelease) <= 8)
    1924. 

  1924. 		cmd.probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
    1925. 

  1925. 	/* TODO: mix in WLAN_CAPABILITY_PRIVACY */
    1926. 

  1926. 	capability = WLAN_CAPABILITY_IBSS;
    1927. 

  1927. 	cmd.capability = cpu_to_le16(capability);
    1928. 

  1928. 	lbs_add_rates(cmd.rates);
    1929. 

  1929. 

  1930. 

  1931. 	ret = lbs_cmd_with_response(priv, CMD_802_11_AD_HOC_START, &cmd);
    1932. 

  1932. 	if (ret)
    1933. 

  1933. 		goto out;
    1934. 

  1934. 

  1935. 	/*
    1936. 

  1936. 	 * This is a sample response to CMD_802_11_AD_HOC_JOIN:
    1937. 

  1937. 	 *
    1938. 

  1938. 	 * response        2b 80
    1939. 

  1939. 	 * size            14 00
    1940. 

  1940. 	 * sequence        xx xx
    1941. 

  1941. 	 * result          00 00
    1942. 

  1942. 	 * reserved        00
    1943. 

  1943. 	 * bssid           02 2b 7b 0f 86 0e
    1944. 

  1944. 	 */
    1945. 

  1945. 	lbs_join_post(priv, params, resp->bssid, capability);
    1946. 

  1946. 

  1947.  out:
    1948. 

  1948. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1949. 

  1949. 	return ret;
    1950. 

  1950. }
    1951. 

  1951. 

  1952. 

  1953. static int lbs_join_ibss(struct wiphy *wiphy, struct net_device *dev,
    1954. 

  1954. 		struct cfg80211_ibss_params *params)
    1955. 

  1955. {
    1956. 

  1956. 	struct lbs_private *priv = wiphy_priv(wiphy);
    1957. 

  1957. 	int ret = 0;
    1958. 

  1958. 	struct cfg80211_bss *bss;
    1959. 

  1959. 	DECLARE_SSID_BUF(ssid_buf);
    1960. 

  1960. 

  1961. 	lbs_deb_enter(LBS_DEB_CFG80211);
    1962. 

  1962. 

  1963. 	if (!params->channel) {
    1964. 

  1964. 		ret = -ENOTSUPP;
    1965. 

  1965. 		goto out;
    1966. 

  1966. 	}
    1967. 

  1967. 

  1968. 	ret = lbs_set_channel(priv, params->channel->hw_value);
    1969. 

  1969. 	if (ret)
    1970. 

  1970. 		goto out;
    1971. 

  1971. 

  1972. 	/* Search if someone is beaconing. This assumes that the
    1973. 

  1973. 	 * bss list is populated already */
    1974. 

  1974. 	bss = cfg80211_get_bss(wiphy, params->channel, params->bssid,
    1975. 

  1975. 		params->ssid, params->ssid_len,
    1976. 

  1976. 		WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS);
    1977. 

  1977. 

  1978. 	if (bss) {
    1979. 

  1979. 		ret = lbs_ibss_join_existing(priv, params, bss);
    1980. 

  1980. 		cfg80211_put_bss(bss);
    1981. 

  1981. 	} else
    1982. 

  1982. 		ret = lbs_ibss_start_new(priv, params);
    1983. 

  1983. 

  1984. 

  1985.  out:
    1986. 

  1986. 	lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
    1987. 

  1987. 	return ret;
    1988. 

  1988. }
    1989. 

  1989. 

  1990. 

  1991. static int l…
    1992.

Large files files are truncated, but you can click here to view the full file