wl1271_acx.c 24 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138
  1. /*
  2. * This file is part of wl1271
  3. *
  4. * Copyright (C) 2008-2009 Nokia Corporation
  5. *
  6. * Contact: Luciano Coelho <luciano.coelho@nokia.com>
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License
  10. * version 2 as published by the Free Software Foundation.
  11. *
  12. * This program is distributed in the hope that it will be useful, but
  13. * WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15. * General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20. * 02110-1301 USA
  21. *
  22. */
  23. #include "wl1271_acx.h"
  24. #include <linux/module.h>
  25. #include <linux/platform_device.h>
  26. #include <linux/crc7.h>
  27. #include <linux/spi/spi.h>
  28. #include "wl1271.h"
  29. #include "wl12xx_80211.h"
  30. #include "wl1271_reg.h"
  31. #include "wl1271_ps.h"
  32. int wl1271_acx_wake_up_conditions(struct wl1271 *wl)
  33. {
  34. struct acx_wake_up_condition *wake_up;
  35. int ret;
  36. wl1271_debug(DEBUG_ACX, "acx wake up conditions");
  37. wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
  38. if (!wake_up) {
  39. ret = -ENOMEM;
  40. goto out;
  41. }
  42. wake_up->wake_up_event = wl->conf.conn.wake_up_event;
  43. wake_up->listen_interval = wl->conf.conn.listen_interval;
  44. ret = wl1271_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
  45. wake_up, sizeof(*wake_up));
  46. if (ret < 0) {
  47. wl1271_warning("could not set wake up conditions: %d", ret);
  48. goto out;
  49. }
  50. out:
  51. kfree(wake_up);
  52. return ret;
  53. }
  54. int wl1271_acx_sleep_auth(struct wl1271 *wl, u8 sleep_auth)
  55. {
  56. struct acx_sleep_auth *auth;
  57. int ret;
  58. wl1271_debug(DEBUG_ACX, "acx sleep auth");
  59. auth = kzalloc(sizeof(*auth), GFP_KERNEL);
  60. if (!auth) {
  61. ret = -ENOMEM;
  62. goto out;
  63. }
  64. auth->sleep_auth = sleep_auth;
  65. ret = wl1271_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
  66. if (ret < 0)
  67. return ret;
  68. out:
  69. kfree(auth);
  70. return ret;
  71. }
  72. int wl1271_acx_fw_version(struct wl1271 *wl, char *buf, size_t len)
  73. {
  74. struct acx_revision *rev;
  75. int ret;
  76. wl1271_debug(DEBUG_ACX, "acx fw rev");
  77. rev = kzalloc(sizeof(*rev), GFP_KERNEL);
  78. if (!rev) {
  79. ret = -ENOMEM;
  80. goto out;
  81. }
  82. ret = wl1271_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
  83. if (ret < 0) {
  84. wl1271_warning("ACX_FW_REV interrogate failed");
  85. goto out;
  86. }
  87. /* be careful with the buffer sizes */
  88. strncpy(buf, rev->fw_version, min(len, sizeof(rev->fw_version)));
  89. /*
  90. * if the firmware version string is exactly
  91. * sizeof(rev->fw_version) long or fw_len is less than
  92. * sizeof(rev->fw_version) it won't be null terminated
  93. */
  94. buf[min(len, sizeof(rev->fw_version)) - 1] = '\0';
  95. out:
  96. kfree(rev);
  97. return ret;
  98. }
  99. int wl1271_acx_tx_power(struct wl1271 *wl, int power)
  100. {
  101. struct acx_current_tx_power *acx;
  102. int ret;
  103. wl1271_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
  104. if (power < 0 || power > 25)
  105. return -EINVAL;
  106. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  107. if (!acx) {
  108. ret = -ENOMEM;
  109. goto out;
  110. }
  111. acx->current_tx_power = power * 10;
  112. ret = wl1271_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
  113. if (ret < 0) {
  114. wl1271_warning("configure of tx power failed: %d", ret);
  115. goto out;
  116. }
  117. out:
  118. kfree(acx);
  119. return ret;
  120. }
  121. int wl1271_acx_feature_cfg(struct wl1271 *wl)
  122. {
  123. struct acx_feature_config *feature;
  124. int ret;
  125. wl1271_debug(DEBUG_ACX, "acx feature cfg");
  126. feature = kzalloc(sizeof(*feature), GFP_KERNEL);
  127. if (!feature) {
  128. ret = -ENOMEM;
  129. goto out;
  130. }
  131. /* DF_ENCRYPTION_DISABLE and DF_SNIFF_MODE_ENABLE are disabled */
  132. feature->data_flow_options = 0;
  133. feature->options = 0;
  134. ret = wl1271_cmd_configure(wl, ACX_FEATURE_CFG,
  135. feature, sizeof(*feature));
  136. if (ret < 0) {
  137. wl1271_error("Couldnt set HW encryption");
  138. goto out;
  139. }
  140. out:
  141. kfree(feature);
  142. return ret;
  143. }
  144. int wl1271_acx_mem_map(struct wl1271 *wl, struct acx_header *mem_map,
  145. size_t len)
  146. {
  147. int ret;
  148. wl1271_debug(DEBUG_ACX, "acx mem map");
  149. ret = wl1271_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
  150. if (ret < 0)
  151. return ret;
  152. return 0;
  153. }
  154. int wl1271_acx_rx_msdu_life_time(struct wl1271 *wl)
  155. {
  156. struct acx_rx_msdu_lifetime *acx;
  157. int ret;
  158. wl1271_debug(DEBUG_ACX, "acx rx msdu life time");
  159. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  160. if (!acx) {
  161. ret = -ENOMEM;
  162. goto out;
  163. }
  164. acx->lifetime = cpu_to_le32(wl->conf.rx.rx_msdu_life_time);
  165. ret = wl1271_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
  166. acx, sizeof(*acx));
  167. if (ret < 0) {
  168. wl1271_warning("failed to set rx msdu life time: %d", ret);
  169. goto out;
  170. }
  171. out:
  172. kfree(acx);
  173. return ret;
  174. }
  175. int wl1271_acx_rx_config(struct wl1271 *wl, u32 config, u32 filter)
  176. {
  177. struct acx_rx_config *rx_config;
  178. int ret;
  179. wl1271_debug(DEBUG_ACX, "acx rx config");
  180. rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
  181. if (!rx_config) {
  182. ret = -ENOMEM;
  183. goto out;
  184. }
  185. rx_config->config_options = cpu_to_le32(config);
  186. rx_config->filter_options = cpu_to_le32(filter);
  187. ret = wl1271_cmd_configure(wl, ACX_RX_CFG,
  188. rx_config, sizeof(*rx_config));
  189. if (ret < 0) {
  190. wl1271_warning("failed to set rx config: %d", ret);
  191. goto out;
  192. }
  193. out:
  194. kfree(rx_config);
  195. return ret;
  196. }
  197. int wl1271_acx_pd_threshold(struct wl1271 *wl)
  198. {
  199. struct acx_packet_detection *pd;
  200. int ret;
  201. wl1271_debug(DEBUG_ACX, "acx data pd threshold");
  202. pd = kzalloc(sizeof(*pd), GFP_KERNEL);
  203. if (!pd) {
  204. ret = -ENOMEM;
  205. goto out;
  206. }
  207. pd->threshold = cpu_to_le32(wl->conf.rx.packet_detection_threshold);
  208. ret = wl1271_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
  209. if (ret < 0) {
  210. wl1271_warning("failed to set pd threshold: %d", ret);
  211. goto out;
  212. }
  213. out:
  214. kfree(pd);
  215. return 0;
  216. }
  217. int wl1271_acx_slot(struct wl1271 *wl, enum acx_slot_type slot_time)
  218. {
  219. struct acx_slot *slot;
  220. int ret;
  221. wl1271_debug(DEBUG_ACX, "acx slot");
  222. slot = kzalloc(sizeof(*slot), GFP_KERNEL);
  223. if (!slot) {
  224. ret = -ENOMEM;
  225. goto out;
  226. }
  227. slot->wone_index = STATION_WONE_INDEX;
  228. slot->slot_time = slot_time;
  229. ret = wl1271_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
  230. if (ret < 0) {
  231. wl1271_warning("failed to set slot time: %d", ret);
  232. goto out;
  233. }
  234. out:
  235. kfree(slot);
  236. return ret;
  237. }
  238. int wl1271_acx_group_address_tbl(struct wl1271 *wl, bool enable,
  239. void *mc_list, u32 mc_list_len)
  240. {
  241. struct acx_dot11_grp_addr_tbl *acx;
  242. int ret;
  243. wl1271_debug(DEBUG_ACX, "acx group address tbl");
  244. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  245. if (!acx) {
  246. ret = -ENOMEM;
  247. goto out;
  248. }
  249. /* MAC filtering */
  250. acx->enabled = enable;
  251. acx->num_groups = mc_list_len;
  252. memcpy(acx->mac_table, mc_list, mc_list_len * ETH_ALEN);
  253. ret = wl1271_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
  254. acx, sizeof(*acx));
  255. if (ret < 0) {
  256. wl1271_warning("failed to set group addr table: %d", ret);
  257. goto out;
  258. }
  259. out:
  260. kfree(acx);
  261. return ret;
  262. }
  263. int wl1271_acx_service_period_timeout(struct wl1271 *wl)
  264. {
  265. struct acx_rx_timeout *rx_timeout;
  266. int ret;
  267. rx_timeout = kzalloc(sizeof(*rx_timeout), GFP_KERNEL);
  268. if (!rx_timeout) {
  269. ret = -ENOMEM;
  270. goto out;
  271. }
  272. wl1271_debug(DEBUG_ACX, "acx service period timeout");
  273. rx_timeout->ps_poll_timeout = cpu_to_le16(wl->conf.rx.ps_poll_timeout);
  274. rx_timeout->upsd_timeout = cpu_to_le16(wl->conf.rx.upsd_timeout);
  275. ret = wl1271_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
  276. rx_timeout, sizeof(*rx_timeout));
  277. if (ret < 0) {
  278. wl1271_warning("failed to set service period timeout: %d",
  279. ret);
  280. goto out;
  281. }
  282. out:
  283. kfree(rx_timeout);
  284. return ret;
  285. }
  286. int wl1271_acx_rts_threshold(struct wl1271 *wl, u16 rts_threshold)
  287. {
  288. struct acx_rts_threshold *rts;
  289. int ret;
  290. wl1271_debug(DEBUG_ACX, "acx rts threshold");
  291. rts = kzalloc(sizeof(*rts), GFP_KERNEL);
  292. if (!rts) {
  293. ret = -ENOMEM;
  294. goto out;
  295. }
  296. rts->threshold = cpu_to_le16(rts_threshold);
  297. ret = wl1271_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
  298. if (ret < 0) {
  299. wl1271_warning("failed to set rts threshold: %d", ret);
  300. goto out;
  301. }
  302. out:
  303. kfree(rts);
  304. return ret;
  305. }
  306. int wl1271_acx_dco_itrim_params(struct wl1271 *wl)
  307. {
  308. struct acx_dco_itrim_params *dco;
  309. struct conf_itrim_settings *c = &wl->conf.itrim;
  310. int ret;
  311. wl1271_debug(DEBUG_ACX, "acx dco itrim parameters");
  312. dco = kzalloc(sizeof(*dco), GFP_KERNEL);
  313. if (!dco) {
  314. ret = -ENOMEM;
  315. goto out;
  316. }
  317. dco->enable = c->enable;
  318. dco->timeout = cpu_to_le32(c->timeout);
  319. ret = wl1271_cmd_configure(wl, ACX_SET_DCO_ITRIM_PARAMS,
  320. dco, sizeof(*dco));
  321. if (ret < 0) {
  322. wl1271_warning("failed to set dco itrim parameters: %d", ret);
  323. goto out;
  324. }
  325. out:
  326. kfree(dco);
  327. return ret;
  328. }
  329. int wl1271_acx_beacon_filter_opt(struct wl1271 *wl, bool enable_filter)
  330. {
  331. struct acx_beacon_filter_option *beacon_filter = NULL;
  332. int ret = 0;
  333. wl1271_debug(DEBUG_ACX, "acx beacon filter opt");
  334. if (enable_filter &&
  335. wl->conf.conn.bcn_filt_mode == CONF_BCN_FILT_MODE_DISABLED)
  336. goto out;
  337. beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
  338. if (!beacon_filter) {
  339. ret = -ENOMEM;
  340. goto out;
  341. }
  342. beacon_filter->enable = enable_filter;
  343. /*
  344. * When set to zero, and the filter is enabled, beacons
  345. * without the unicast TIM bit set are dropped.
  346. */
  347. beacon_filter->max_num_beacons = 0;
  348. ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
  349. beacon_filter, sizeof(*beacon_filter));
  350. if (ret < 0) {
  351. wl1271_warning("failed to set beacon filter opt: %d", ret);
  352. goto out;
  353. }
  354. out:
  355. kfree(beacon_filter);
  356. return ret;
  357. }
  358. int wl1271_acx_beacon_filter_table(struct wl1271 *wl)
  359. {
  360. struct acx_beacon_filter_ie_table *ie_table;
  361. int i, idx = 0;
  362. int ret;
  363. bool vendor_spec = false;
  364. wl1271_debug(DEBUG_ACX, "acx beacon filter table");
  365. ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
  366. if (!ie_table) {
  367. ret = -ENOMEM;
  368. goto out;
  369. }
  370. /* configure default beacon pass-through rules */
  371. ie_table->num_ie = 0;
  372. for (i = 0; i < wl->conf.conn.bcn_filt_ie_count; i++) {
  373. struct conf_bcn_filt_rule *r = &(wl->conf.conn.bcn_filt_ie[i]);
  374. ie_table->table[idx++] = r->ie;
  375. ie_table->table[idx++] = r->rule;
  376. if (r->ie == WLAN_EID_VENDOR_SPECIFIC) {
  377. /* only one vendor specific ie allowed */
  378. if (vendor_spec)
  379. continue;
  380. /* for vendor specific rules configure the
  381. additional fields */
  382. memcpy(&(ie_table->table[idx]), r->oui,
  383. CONF_BCN_IE_OUI_LEN);
  384. idx += CONF_BCN_IE_OUI_LEN;
  385. ie_table->table[idx++] = r->type;
  386. memcpy(&(ie_table->table[idx]), r->version,
  387. CONF_BCN_IE_VER_LEN);
  388. idx += CONF_BCN_IE_VER_LEN;
  389. vendor_spec = true;
  390. }
  391. ie_table->num_ie++;
  392. }
  393. ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
  394. ie_table, sizeof(*ie_table));
  395. if (ret < 0) {
  396. wl1271_warning("failed to set beacon filter table: %d", ret);
  397. goto out;
  398. }
  399. out:
  400. kfree(ie_table);
  401. return ret;
  402. }
  403. int wl1271_acx_conn_monit_params(struct wl1271 *wl)
  404. {
  405. struct acx_conn_monit_params *acx;
  406. int ret;
  407. wl1271_debug(DEBUG_ACX, "acx connection monitor parameters");
  408. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  409. if (!acx) {
  410. ret = -ENOMEM;
  411. goto out;
  412. }
  413. acx->synch_fail_thold = cpu_to_le32(wl->conf.conn.synch_fail_thold);
  414. acx->bss_lose_timeout = cpu_to_le32(wl->conf.conn.bss_lose_timeout);
  415. ret = wl1271_cmd_configure(wl, ACX_CONN_MONIT_PARAMS,
  416. acx, sizeof(*acx));
  417. if (ret < 0) {
  418. wl1271_warning("failed to set connection monitor "
  419. "parameters: %d", ret);
  420. goto out;
  421. }
  422. out:
  423. kfree(acx);
  424. return ret;
  425. }
  426. int wl1271_acx_sg_enable(struct wl1271 *wl)
  427. {
  428. struct acx_bt_wlan_coex *pta;
  429. int ret;
  430. wl1271_debug(DEBUG_ACX, "acx sg enable");
  431. pta = kzalloc(sizeof(*pta), GFP_KERNEL);
  432. if (!pta) {
  433. ret = -ENOMEM;
  434. goto out;
  435. }
  436. pta->enable = SG_ENABLE;
  437. ret = wl1271_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
  438. if (ret < 0) {
  439. wl1271_warning("failed to set softgemini enable: %d", ret);
  440. goto out;
  441. }
  442. out:
  443. kfree(pta);
  444. return ret;
  445. }
  446. int wl1271_acx_sg_cfg(struct wl1271 *wl)
  447. {
  448. struct acx_bt_wlan_coex_param *param;
  449. struct conf_sg_settings *c = &wl->conf.sg;
  450. int ret;
  451. wl1271_debug(DEBUG_ACX, "acx sg cfg");
  452. param = kzalloc(sizeof(*param), GFP_KERNEL);
  453. if (!param) {
  454. ret = -ENOMEM;
  455. goto out;
  456. }
  457. /* BT-WLAN coext parameters */
  458. param->per_threshold = cpu_to_le32(c->per_threshold);
  459. param->max_scan_compensation_time =
  460. cpu_to_le32(c->max_scan_compensation_time);
  461. param->nfs_sample_interval = cpu_to_le16(c->nfs_sample_interval);
  462. param->load_ratio = c->load_ratio;
  463. param->auto_ps_mode = c->auto_ps_mode;
  464. param->probe_req_compensation = c->probe_req_compensation;
  465. param->scan_window_compensation = c->scan_window_compensation;
  466. param->antenna_config = c->antenna_config;
  467. param->beacon_miss_threshold = c->beacon_miss_threshold;
  468. param->rate_adaptation_threshold =
  469. cpu_to_le32(c->rate_adaptation_threshold);
  470. param->rate_adaptation_snr = c->rate_adaptation_snr;
  471. ret = wl1271_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
  472. if (ret < 0) {
  473. wl1271_warning("failed to set sg config: %d", ret);
  474. goto out;
  475. }
  476. out:
  477. kfree(param);
  478. return ret;
  479. }
  480. int wl1271_acx_cca_threshold(struct wl1271 *wl)
  481. {
  482. struct acx_energy_detection *detection;
  483. int ret;
  484. wl1271_debug(DEBUG_ACX, "acx cca threshold");
  485. detection = kzalloc(sizeof(*detection), GFP_KERNEL);
  486. if (!detection) {
  487. ret = -ENOMEM;
  488. goto out;
  489. }
  490. detection->rx_cca_threshold = cpu_to_le16(wl->conf.rx.rx_cca_threshold);
  491. detection->tx_energy_detection = wl->conf.tx.tx_energy_detection;
  492. ret = wl1271_cmd_configure(wl, ACX_CCA_THRESHOLD,
  493. detection, sizeof(*detection));
  494. if (ret < 0) {
  495. wl1271_warning("failed to set cca threshold: %d", ret);
  496. return ret;
  497. }
  498. out:
  499. kfree(detection);
  500. return ret;
  501. }
  502. int wl1271_acx_bcn_dtim_options(struct wl1271 *wl)
  503. {
  504. struct acx_beacon_broadcast *bb;
  505. int ret;
  506. wl1271_debug(DEBUG_ACX, "acx bcn dtim options");
  507. bb = kzalloc(sizeof(*bb), GFP_KERNEL);
  508. if (!bb) {
  509. ret = -ENOMEM;
  510. goto out;
  511. }
  512. bb->beacon_rx_timeout = cpu_to_le16(wl->conf.conn.beacon_rx_timeout);
  513. bb->broadcast_timeout = cpu_to_le16(wl->conf.conn.broadcast_timeout);
  514. bb->rx_broadcast_in_ps = wl->conf.conn.rx_broadcast_in_ps;
  515. bb->ps_poll_threshold = wl->conf.conn.ps_poll_threshold;
  516. ret = wl1271_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
  517. if (ret < 0) {
  518. wl1271_warning("failed to set rx config: %d", ret);
  519. goto out;
  520. }
  521. out:
  522. kfree(bb);
  523. return ret;
  524. }
  525. int wl1271_acx_aid(struct wl1271 *wl, u16 aid)
  526. {
  527. struct acx_aid *acx_aid;
  528. int ret;
  529. wl1271_debug(DEBUG_ACX, "acx aid");
  530. acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
  531. if (!acx_aid) {
  532. ret = -ENOMEM;
  533. goto out;
  534. }
  535. acx_aid->aid = cpu_to_le16(aid);
  536. ret = wl1271_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
  537. if (ret < 0) {
  538. wl1271_warning("failed to set aid: %d", ret);
  539. goto out;
  540. }
  541. out:
  542. kfree(acx_aid);
  543. return ret;
  544. }
  545. int wl1271_acx_event_mbox_mask(struct wl1271 *wl, u32 event_mask)
  546. {
  547. struct acx_event_mask *mask;
  548. int ret;
  549. wl1271_debug(DEBUG_ACX, "acx event mbox mask");
  550. mask = kzalloc(sizeof(*mask), GFP_KERNEL);
  551. if (!mask) {
  552. ret = -ENOMEM;
  553. goto out;
  554. }
  555. /* high event mask is unused */
  556. mask->high_event_mask = cpu_to_le32(0xffffffff);
  557. mask->event_mask = cpu_to_le32(event_mask);
  558. ret = wl1271_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
  559. mask, sizeof(*mask));
  560. if (ret < 0) {
  561. wl1271_warning("failed to set acx_event_mbox_mask: %d", ret);
  562. goto out;
  563. }
  564. out:
  565. kfree(mask);
  566. return ret;
  567. }
  568. int wl1271_acx_set_preamble(struct wl1271 *wl, enum acx_preamble_type preamble)
  569. {
  570. struct acx_preamble *acx;
  571. int ret;
  572. wl1271_debug(DEBUG_ACX, "acx_set_preamble");
  573. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  574. if (!acx) {
  575. ret = -ENOMEM;
  576. goto out;
  577. }
  578. acx->preamble = preamble;
  579. ret = wl1271_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
  580. if (ret < 0) {
  581. wl1271_warning("Setting of preamble failed: %d", ret);
  582. goto out;
  583. }
  584. out:
  585. kfree(acx);
  586. return ret;
  587. }
  588. int wl1271_acx_cts_protect(struct wl1271 *wl,
  589. enum acx_ctsprotect_type ctsprotect)
  590. {
  591. struct acx_ctsprotect *acx;
  592. int ret;
  593. wl1271_debug(DEBUG_ACX, "acx_set_ctsprotect");
  594. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  595. if (!acx) {
  596. ret = -ENOMEM;
  597. goto out;
  598. }
  599. acx->ctsprotect = ctsprotect;
  600. ret = wl1271_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
  601. if (ret < 0) {
  602. wl1271_warning("Setting of ctsprotect failed: %d", ret);
  603. goto out;
  604. }
  605. out:
  606. kfree(acx);
  607. return ret;
  608. }
  609. int wl1271_acx_statistics(struct wl1271 *wl, struct acx_statistics *stats)
  610. {
  611. int ret;
  612. wl1271_debug(DEBUG_ACX, "acx statistics");
  613. ret = wl1271_cmd_interrogate(wl, ACX_STATISTICS, stats,
  614. sizeof(*stats));
  615. if (ret < 0) {
  616. wl1271_warning("acx statistics failed: %d", ret);
  617. return -ENOMEM;
  618. }
  619. return 0;
  620. }
  621. int wl1271_acx_rate_policies(struct wl1271 *wl)
  622. {
  623. struct acx_rate_policy *acx;
  624. struct conf_tx_rate_class *c = &wl->conf.tx.rc_conf;
  625. int idx = 0;
  626. int ret = 0;
  627. wl1271_debug(DEBUG_ACX, "acx rate policies");
  628. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  629. if (!acx) {
  630. ret = -ENOMEM;
  631. goto out;
  632. }
  633. /* configure one basic rate class */
  634. idx = ACX_TX_BASIC_RATE;
  635. acx->rate_class[idx].enabled_rates = cpu_to_le32(wl->basic_rate_set);
  636. acx->rate_class[idx].short_retry_limit = c->short_retry_limit;
  637. acx->rate_class[idx].long_retry_limit = c->long_retry_limit;
  638. acx->rate_class[idx].aflags = c->aflags;
  639. /* configure one AP supported rate class */
  640. idx = ACX_TX_AP_FULL_RATE;
  641. acx->rate_class[idx].enabled_rates = cpu_to_le32(wl->rate_set);
  642. acx->rate_class[idx].short_retry_limit = c->short_retry_limit;
  643. acx->rate_class[idx].long_retry_limit = c->long_retry_limit;
  644. acx->rate_class[idx].aflags = c->aflags;
  645. acx->rate_class_cnt = cpu_to_le32(ACX_TX_RATE_POLICY_CNT);
  646. ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
  647. if (ret < 0) {
  648. wl1271_warning("Setting of rate policies failed: %d", ret);
  649. goto out;
  650. }
  651. out:
  652. kfree(acx);
  653. return ret;
  654. }
  655. int wl1271_acx_ac_cfg(struct wl1271 *wl, u8 ac, u8 cw_min, u16 cw_max,
  656. u8 aifsn, u16 txop)
  657. {
  658. struct acx_ac_cfg *acx;
  659. int ret = 0;
  660. wl1271_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d "
  661. "aifs %d txop %d", ac, cw_min, cw_max, aifsn, txop);
  662. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  663. if (!acx) {
  664. ret = -ENOMEM;
  665. goto out;
  666. }
  667. acx->ac = ac;
  668. acx->cw_min = cw_min;
  669. acx->cw_max = cpu_to_le16(cw_max);
  670. acx->aifsn = aifsn;
  671. acx->tx_op_limit = cpu_to_le16(txop);
  672. ret = wl1271_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx));
  673. if (ret < 0) {
  674. wl1271_warning("acx ac cfg failed: %d", ret);
  675. goto out;
  676. }
  677. out:
  678. kfree(acx);
  679. return ret;
  680. }
  681. int wl1271_acx_tid_cfg(struct wl1271 *wl, u8 queue_id, u8 channel_type,
  682. u8 tsid, u8 ps_scheme, u8 ack_policy,
  683. u32 apsd_conf0, u32 apsd_conf1)
  684. {
  685. struct acx_tid_config *acx;
  686. int ret = 0;
  687. wl1271_debug(DEBUG_ACX, "acx tid config");
  688. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  689. if (!acx) {
  690. ret = -ENOMEM;
  691. goto out;
  692. }
  693. acx->queue_id = queue_id;
  694. acx->channel_type = channel_type;
  695. acx->tsid = tsid;
  696. acx->ps_scheme = ps_scheme;
  697. acx->ack_policy = ack_policy;
  698. acx->apsd_conf[0] = cpu_to_le32(apsd_conf0);
  699. acx->apsd_conf[1] = cpu_to_le32(apsd_conf1);
  700. ret = wl1271_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx));
  701. if (ret < 0) {
  702. wl1271_warning("Setting of tid config failed: %d", ret);
  703. goto out;
  704. }
  705. out:
  706. kfree(acx);
  707. return ret;
  708. }
  709. int wl1271_acx_frag_threshold(struct wl1271 *wl)
  710. {
  711. struct acx_frag_threshold *acx;
  712. int ret = 0;
  713. wl1271_debug(DEBUG_ACX, "acx frag threshold");
  714. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  715. if (!acx) {
  716. ret = -ENOMEM;
  717. goto out;
  718. }
  719. acx->frag_threshold = cpu_to_le16(wl->conf.tx.frag_threshold);
  720. ret = wl1271_cmd_configure(wl, ACX_FRAG_CFG, acx, sizeof(*acx));
  721. if (ret < 0) {
  722. wl1271_warning("Setting of frag threshold failed: %d", ret);
  723. goto out;
  724. }
  725. out:
  726. kfree(acx);
  727. return ret;
  728. }
  729. int wl1271_acx_tx_config_options(struct wl1271 *wl)
  730. {
  731. struct acx_tx_config_options *acx;
  732. int ret = 0;
  733. wl1271_debug(DEBUG_ACX, "acx tx config options");
  734. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  735. if (!acx) {
  736. ret = -ENOMEM;
  737. goto out;
  738. }
  739. acx->tx_compl_timeout = cpu_to_le16(wl->conf.tx.tx_compl_timeout);
  740. acx->tx_compl_threshold = cpu_to_le16(wl->conf.tx.tx_compl_threshold);
  741. ret = wl1271_cmd_configure(wl, ACX_TX_CONFIG_OPT, acx, sizeof(*acx));
  742. if (ret < 0) {
  743. wl1271_warning("Setting of tx options failed: %d", ret);
  744. goto out;
  745. }
  746. out:
  747. kfree(acx);
  748. return ret;
  749. }
  750. int wl1271_acx_mem_cfg(struct wl1271 *wl)
  751. {
  752. struct wl1271_acx_config_memory *mem_conf;
  753. int ret;
  754. wl1271_debug(DEBUG_ACX, "wl1271 mem cfg");
  755. mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
  756. if (!mem_conf) {
  757. ret = -ENOMEM;
  758. goto out;
  759. }
  760. /* memory config */
  761. mem_conf->num_stations = DEFAULT_NUM_STATIONS;
  762. mem_conf->rx_mem_block_num = ACX_RX_MEM_BLOCKS;
  763. mem_conf->tx_min_mem_block_num = ACX_TX_MIN_MEM_BLOCKS;
  764. mem_conf->num_ssid_profiles = ACX_NUM_SSID_PROFILES;
  765. mem_conf->total_tx_descriptors = cpu_to_le32(ACX_TX_DESCRIPTORS);
  766. ret = wl1271_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
  767. sizeof(*mem_conf));
  768. if (ret < 0) {
  769. wl1271_warning("wl1271 mem config failed: %d", ret);
  770. goto out;
  771. }
  772. out:
  773. kfree(mem_conf);
  774. return ret;
  775. }
  776. int wl1271_acx_init_mem_config(struct wl1271 *wl)
  777. {
  778. int ret;
  779. ret = wl1271_acx_mem_cfg(wl);
  780. if (ret < 0)
  781. return ret;
  782. wl->target_mem_map = kzalloc(sizeof(struct wl1271_acx_mem_map),
  783. GFP_KERNEL);
  784. if (!wl->target_mem_map) {
  785. wl1271_error("couldn't allocate target memory map");
  786. return -ENOMEM;
  787. }
  788. /* we now ask for the firmware built memory map */
  789. ret = wl1271_acx_mem_map(wl, (void *)wl->target_mem_map,
  790. sizeof(struct wl1271_acx_mem_map));
  791. if (ret < 0) {
  792. wl1271_error("couldn't retrieve firmware memory map");
  793. kfree(wl->target_mem_map);
  794. wl->target_mem_map = NULL;
  795. return ret;
  796. }
  797. /* initialize TX block book keeping */
  798. wl->tx_blocks_available =
  799. le32_to_cpu(wl->target_mem_map->num_tx_mem_blocks);
  800. wl1271_debug(DEBUG_TX, "available tx blocks: %d",
  801. wl->tx_blocks_available);
  802. return 0;
  803. }
  804. int wl1271_acx_init_rx_interrupt(struct wl1271 *wl)
  805. {
  806. struct wl1271_acx_rx_config_opt *rx_conf;
  807. int ret;
  808. wl1271_debug(DEBUG_ACX, "wl1271 rx interrupt config");
  809. rx_conf = kzalloc(sizeof(*rx_conf), GFP_KERNEL);
  810. if (!rx_conf) {
  811. ret = -ENOMEM;
  812. goto out;
  813. }
  814. rx_conf->threshold = cpu_to_le16(wl->conf.rx.irq_pkt_threshold);
  815. rx_conf->timeout = cpu_to_le16(wl->conf.rx.irq_timeout);
  816. rx_conf->mblk_threshold = cpu_to_le16(wl->conf.rx.irq_blk_threshold);
  817. rx_conf->queue_type = wl->conf.rx.queue_type;
  818. ret = wl1271_cmd_configure(wl, ACX_RX_CONFIG_OPT, rx_conf,
  819. sizeof(*rx_conf));
  820. if (ret < 0) {
  821. wl1271_warning("wl1271 rx config opt failed: %d", ret);
  822. goto out;
  823. }
  824. out:
  825. kfree(rx_conf);
  826. return ret;
  827. }
  828. int wl1271_acx_bet_enable(struct wl1271 *wl, bool enable)
  829. {
  830. struct wl1271_acx_bet_enable *acx = NULL;
  831. int ret = 0;
  832. wl1271_debug(DEBUG_ACX, "acx bet enable");
  833. if (enable && wl->conf.conn.bet_enable == CONF_BET_MODE_DISABLE)
  834. goto out;
  835. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  836. if (!acx) {
  837. ret = -ENOMEM;
  838. goto out;
  839. }
  840. acx->enable = enable ? CONF_BET_MODE_ENABLE : CONF_BET_MODE_DISABLE;
  841. acx->max_consecutive = wl->conf.conn.bet_max_consecutive;
  842. ret = wl1271_cmd_configure(wl, ACX_BET_ENABLE, acx, sizeof(*acx));
  843. if (ret < 0) {
  844. wl1271_warning("acx bet enable failed: %d", ret);
  845. goto out;
  846. }
  847. out:
  848. kfree(acx);
  849. return ret;
  850. }
  851. int wl1271_acx_arp_ip_filter(struct wl1271 *wl, bool enable, u8 *address,
  852. u8 version)
  853. {
  854. struct wl1271_acx_arp_filter *acx;
  855. int ret;
  856. wl1271_debug(DEBUG_ACX, "acx arp ip filter, enable: %d", enable);
  857. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  858. if (!acx) {
  859. ret = -ENOMEM;
  860. goto out;
  861. }
  862. acx->version = version;
  863. acx->enable = enable;
  864. if (enable == true) {
  865. if (version == ACX_IPV4_VERSION)
  866. memcpy(acx->address, address, ACX_IPV4_ADDR_SIZE);
  867. else if (version == ACX_IPV6_VERSION)
  868. memcpy(acx->address, address, sizeof(acx->address));
  869. else
  870. wl1271_error("Invalid IP version");
  871. }
  872. ret = wl1271_cmd_configure(wl, ACX_ARP_IP_FILTER,
  873. acx, sizeof(*acx));
  874. if (ret < 0) {
  875. wl1271_warning("failed to set arp ip filter: %d", ret);
  876. goto out;
  877. }
  878. out:
  879. kfree(acx);
  880. return ret;
  881. }
  882. int wl1271_acx_pm_config(struct wl1271 *wl)
  883. {
  884. struct wl1271_acx_pm_config *acx = NULL;
  885. struct conf_pm_config_settings *c = &wl->conf.pm_config;
  886. int ret = 0;
  887. wl1271_debug(DEBUG_ACX, "acx pm config");
  888. acx = kzalloc(sizeof(*acx), GFP_KERNEL);
  889. if (!acx) {
  890. ret = -ENOMEM;
  891. goto out;
  892. }
  893. acx->host_clk_settling_time = cpu_to_le32(c->host_clk_settling_time);
  894. acx->host_fast_wakeup_support = c->host_fast_wakeup_support;
  895. ret = wl1271_cmd_configure(wl, ACX_PM_CONFIG, acx, sizeof(*acx));
  896. if (ret < 0) {
  897. wl1271_warning("acx pm config failed: %d", ret);
  898. goto out;
  899. }
  900. out:
  901. kfree(acx);
  902. return ret;
  903. }