← Back to branch summary

~ubuntu-branches/ubuntu/natty/linux-backports-modules-2.6.38/natty-proposed

« back to all changes in this revision

Viewing changes to updates/cw-2.6.39/drivers/net/wireless/wl1251/acx.c

  • Committer: Bazaar Package Importer
  • Author(s): Tim Gardner, Tim Gardner
  • Date: 2011-06-08 10:44:09 UTC
  • Revision ID: james.westby@ubuntu.com-20110608104409-fnl8carkdo15bwsz
Tags: 2.6.38-10.6
[ Tim Gardner ]

Shorten compat-wireless package name to cw to accomodate
CDROM file name length restrictions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/cw-2.6.39/drivers/net/wireless/wl1251/acx.c
 
1
#include "acx.h"
 
2
 
 
3
#include <linux/module.h>
 
4
#include <linux/slab.h>
 
5
#include <linux/crc7.h>
 
6
 
 
7
#include "wl1251.h"
 
8
#include "reg.h"
 
9
#include "cmd.h"
 
10
#include "ps.h"
 
11
 
 
12
int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
 
13
                           u8 mgt_rate, u8 mgt_mod)
 
14
{
 
15
        struct acx_fw_gen_frame_rates *rates;
 
16
        int ret;
 
17
 
 
18
        wl1251_debug(DEBUG_ACX, "acx frame rates");
 
19
 
 
20
        rates = kzalloc(sizeof(*rates), GFP_KERNEL);
 
21
        if (!rates) {
 
22
                ret = -ENOMEM;
 
23
                goto out;
 
24
        }
 
25
 
 
26
        rates->tx_ctrl_frame_rate = ctrl_rate;
 
27
        rates->tx_ctrl_frame_mod = ctrl_mod;
 
28
        rates->tx_mgt_frame_rate = mgt_rate;
 
29
        rates->tx_mgt_frame_mod = mgt_mod;
 
30
 
 
31
        ret = wl1251_cmd_configure(wl, ACX_FW_GEN_FRAME_RATES,
 
32
                                   rates, sizeof(*rates));
 
33
        if (ret < 0) {
 
34
                wl1251_error("Failed to set FW rates and modulation");
 
35
                goto out;
 
36
        }
 
37
 
 
38
out:
 
39
        kfree(rates);
 
40
        return ret;
 
41
}
 
42
 
 
43
 
 
44
int wl1251_acx_station_id(struct wl1251 *wl)
 
45
{
 
46
        struct acx_dot11_station_id *mac;
 
47
        int ret, i;
 
48
 
 
49
        wl1251_debug(DEBUG_ACX, "acx dot11_station_id");
 
50
 
 
51
        mac = kzalloc(sizeof(*mac), GFP_KERNEL);
 
52
        if (!mac) {
 
53
                ret = -ENOMEM;
 
54
                goto out;
 
55
        }
 
56
 
 
57
        for (i = 0; i < ETH_ALEN; i++)
 
58
                mac->mac[i] = wl->mac_addr[ETH_ALEN - 1 - i];
 
59
 
 
60
        ret = wl1251_cmd_configure(wl, DOT11_STATION_ID, mac, sizeof(*mac));
 
61
        if (ret < 0)
 
62
                goto out;
 
63
 
 
64
out:
 
65
        kfree(mac);
 
66
        return ret;
 
67
}
 
68
 
 
69
int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id)
 
70
{
 
71
        struct acx_dot11_default_key *default_key;
 
72
        int ret;
 
73
 
 
74
        wl1251_debug(DEBUG_ACX, "acx dot11_default_key (%d)", key_id);
 
75
 
 
76
        default_key = kzalloc(sizeof(*default_key), GFP_KERNEL);
 
77
        if (!default_key) {
 
78
                ret = -ENOMEM;
 
79
                goto out;
 
80
        }
 
81
 
 
82
        default_key->id = key_id;
 
83
 
 
84
        ret = wl1251_cmd_configure(wl, DOT11_DEFAULT_KEY,
 
85
                                   default_key, sizeof(*default_key));
 
86
        if (ret < 0) {
 
87
                wl1251_error("Couldn't set default key");
 
88
                goto out;
 
89
        }
 
90
 
 
91
        wl->default_key = key_id;
 
92
 
 
93
out:
 
94
        kfree(default_key);
 
95
        return ret;
 
96
}
 
97
 
 
98
int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
 
99
                                  u8 listen_interval)
 
100
{
 
101
        struct acx_wake_up_condition *wake_up;
 
102
        int ret;
 
103
 
 
104
        wl1251_debug(DEBUG_ACX, "acx wake up conditions");
 
105
 
 
106
        wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
 
107
        if (!wake_up) {
 
108
                ret = -ENOMEM;
 
109
                goto out;
 
110
        }
 
111
 
 
112
        wake_up->wake_up_event = wake_up_event;
 
113
        wake_up->listen_interval = listen_interval;
 
114
 
 
115
        ret = wl1251_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
 
116
                                   wake_up, sizeof(*wake_up));
 
117
        if (ret < 0) {
 
118
                wl1251_warning("could not set wake up conditions: %d", ret);
 
119
                goto out;
 
120
        }
 
121
 
 
122
out:
 
123
        kfree(wake_up);
 
124
        return ret;
 
125
}
 
126
 
 
127
int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth)
 
128
{
 
129
        struct acx_sleep_auth *auth;
 
130
        int ret;
 
131
 
 
132
        wl1251_debug(DEBUG_ACX, "acx sleep auth");
 
133
 
 
134
        auth = kzalloc(sizeof(*auth), GFP_KERNEL);
 
135
        if (!auth) {
 
136
                ret = -ENOMEM;
 
137
                goto out;
 
138
        }
 
139
 
 
140
        auth->sleep_auth = sleep_auth;
 
141
 
 
142
        ret = wl1251_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
 
143
        if (ret < 0)
 
144
                return ret;
 
145
 
 
146
out:
 
147
        kfree(auth);
 
148
        return ret;
 
149
}
 
150
 
 
151
int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len)
 
152
{
 
153
        struct acx_revision *rev;
 
154
        int ret;
 
155
 
 
156
        wl1251_debug(DEBUG_ACX, "acx fw rev");
 
157
 
 
158
        rev = kzalloc(sizeof(*rev), GFP_KERNEL);
 
159
        if (!rev) {
 
160
                ret = -ENOMEM;
 
161
                goto out;
 
162
        }
 
163
 
 
164
        ret = wl1251_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
 
165
        if (ret < 0) {
 
166
                wl1251_warning("ACX_FW_REV interrogate failed");
 
167
                goto out;
 
168
        }
 
169
 
 
170
        /* be careful with the buffer sizes */
 
171
        strncpy(buf, rev->fw_version, min(len, sizeof(rev->fw_version)));
 
172
 
 
173
        /*
 
174
         * if the firmware version string is exactly
 
175
         * sizeof(rev->fw_version) long or fw_len is less than
 
176
         * sizeof(rev->fw_version) it won't be null terminated
 
177
         */
 
178
        buf[min(len, sizeof(rev->fw_version)) - 1] = '\0';
 
179
 
 
180
out:
 
181
        kfree(rev);
 
182
        return ret;
 
183
}
 
184
 
 
185
int wl1251_acx_tx_power(struct wl1251 *wl, int power)
 
186
{
 
187
        struct acx_current_tx_power *acx;
 
188
        int ret;
 
189
 
 
190
        wl1251_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
 
191
 
 
192
        if (power < 0 || power > 25)
 
193
                return -EINVAL;
 
194
 
 
195
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
196
        if (!acx) {
 
197
                ret = -ENOMEM;
 
198
                goto out;
 
199
        }
 
200
 
 
201
        acx->current_tx_power = power * 10;
 
202
 
 
203
        ret = wl1251_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
 
204
        if (ret < 0) {
 
205
                wl1251_warning("configure of tx power failed: %d", ret);
 
206
                goto out;
 
207
        }
 
208
 
 
209
out:
 
210
        kfree(acx);
 
211
        return ret;
 
212
}
 
213
 
 
214
int wl1251_acx_feature_cfg(struct wl1251 *wl)
 
215
{
 
216
        struct acx_feature_config *feature;
 
217
        int ret;
 
218
 
 
219
        wl1251_debug(DEBUG_ACX, "acx feature cfg");
 
220
 
 
221
        feature = kzalloc(sizeof(*feature), GFP_KERNEL);
 
222
        if (!feature) {
 
223
                ret = -ENOMEM;
 
224
                goto out;
 
225
        }
 
226
 
 
227
        /* DF_ENCRYPTION_DISABLE and DF_SNIFF_MODE_ENABLE are disabled */
 
228
        feature->data_flow_options = 0;
 
229
        feature->options = 0;
 
230
 
 
231
        ret = wl1251_cmd_configure(wl, ACX_FEATURE_CFG,
 
232
                                   feature, sizeof(*feature));
 
233
        if (ret < 0) {
 
234
                wl1251_error("Couldn't set HW encryption");
 
235
                goto out;
 
236
        }
 
237
 
 
238
out:
 
239
        kfree(feature);
 
240
        return ret;
 
241
}
 
242
 
 
243
int wl1251_acx_mem_map(struct wl1251 *wl, struct acx_header *mem_map,
 
244
                       size_t len)
 
245
{
 
246
        int ret;
 
247
 
 
248
        wl1251_debug(DEBUG_ACX, "acx mem map");
 
249
 
 
250
        ret = wl1251_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
 
251
        if (ret < 0)
 
252
                return ret;
 
253
 
 
254
        return 0;
 
255
}
 
256
 
 
257
int wl1251_acx_data_path_params(struct wl1251 *wl,
 
258
                                struct acx_data_path_params_resp *resp)
 
259
{
 
260
        struct acx_data_path_params *params;
 
261
        int ret;
 
262
 
 
263
        wl1251_debug(DEBUG_ACX, "acx data path params");
 
264
 
 
265
        params = kzalloc(sizeof(*params), GFP_KERNEL);
 
266
        if (!params) {
 
267
                ret = -ENOMEM;
 
268
                goto out;
 
269
        }
 
270
 
 
271
        params->rx_packet_ring_chunk_size = DP_RX_PACKET_RING_CHUNK_SIZE;
 
272
        params->tx_packet_ring_chunk_size = DP_TX_PACKET_RING_CHUNK_SIZE;
 
273
 
 
274
        params->rx_packet_ring_chunk_num = DP_RX_PACKET_RING_CHUNK_NUM;
 
275
        params->tx_packet_ring_chunk_num = DP_TX_PACKET_RING_CHUNK_NUM;
 
276
 
 
277
        params->tx_complete_threshold = 1;
 
278
 
 
279
        params->tx_complete_ring_depth = FW_TX_CMPLT_BLOCK_SIZE;
 
280
 
 
281
        params->tx_complete_timeout = DP_TX_COMPLETE_TIME_OUT;
 
282
 
 
283
        ret = wl1251_cmd_configure(wl, ACX_DATA_PATH_PARAMS,
 
284
                                   params, sizeof(*params));
 
285
        if (ret < 0)
 
286
                goto out;
 
287
 
 
288
        /* FIXME: shouldn't this be ACX_DATA_PATH_RESP_PARAMS? */
 
289
        ret = wl1251_cmd_interrogate(wl, ACX_DATA_PATH_PARAMS,
 
290
                                     resp, sizeof(*resp));
 
291
 
 
292
        if (ret < 0) {
 
293
                wl1251_warning("failed to read data path parameters: %d", ret);
 
294
                goto out;
 
295
        } else if (resp->header.cmd.status != CMD_STATUS_SUCCESS) {
 
296
                wl1251_warning("data path parameter acx status failed");
 
297
                ret = -EIO;
 
298
                goto out;
 
299
        }
 
300
 
 
301
out:
 
302
        kfree(params);
 
303
        return ret;
 
304
}
 
305
 
 
306
int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time)
 
307
{
 
308
        struct acx_rx_msdu_lifetime *acx;
 
309
        int ret;
 
310
 
 
311
        wl1251_debug(DEBUG_ACX, "acx rx msdu life time");
 
312
 
 
313
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
314
        if (!acx) {
 
315
                ret = -ENOMEM;
 
316
                goto out;
 
317
        }
 
318
 
 
319
        acx->lifetime = life_time;
 
320
        ret = wl1251_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
 
321
                                   acx, sizeof(*acx));
 
322
        if (ret < 0) {
 
323
                wl1251_warning("failed to set rx msdu life time: %d", ret);
 
324
                goto out;
 
325
        }
 
326
 
 
327
out:
 
328
        kfree(acx);
 
329
        return ret;
 
330
}
 
331
 
 
332
int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter)
 
333
{
 
334
        struct acx_rx_config *rx_config;
 
335
        int ret;
 
336
 
 
337
        wl1251_debug(DEBUG_ACX, "acx rx config");
 
338
 
 
339
        rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
 
340
        if (!rx_config) {
 
341
                ret = -ENOMEM;
 
342
                goto out;
 
343
        }
 
344
 
 
345
        rx_config->config_options = config;
 
346
        rx_config->filter_options = filter;
 
347
 
 
348
        ret = wl1251_cmd_configure(wl, ACX_RX_CFG,
 
349
                                   rx_config, sizeof(*rx_config));
 
350
        if (ret < 0) {
 
351
                wl1251_warning("failed to set rx config: %d", ret);
 
352
                goto out;
 
353
        }
 
354
 
 
355
out:
 
356
        kfree(rx_config);
 
357
        return ret;
 
358
}
 
359
 
 
360
int wl1251_acx_pd_threshold(struct wl1251 *wl)
 
361
{
 
362
        struct acx_packet_detection *pd;
 
363
        int ret;
 
364
 
 
365
        wl1251_debug(DEBUG_ACX, "acx data pd threshold");
 
366
 
 
367
        pd = kzalloc(sizeof(*pd), GFP_KERNEL);
 
368
        if (!pd) {
 
369
                ret = -ENOMEM;
 
370
                goto out;
 
371
        }
 
372
 
 
373
        /* FIXME: threshold value not set */
 
374
 
 
375
        ret = wl1251_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
 
376
        if (ret < 0) {
 
377
                wl1251_warning("failed to set pd threshold: %d", ret);
 
378
                goto out;
 
379
        }
 
380
 
 
381
out:
 
382
        kfree(pd);
 
383
        return ret;
 
384
}
 
385
 
 
386
int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time)
 
387
{
 
388
        struct acx_slot *slot;
 
389
        int ret;
 
390
 
 
391
        wl1251_debug(DEBUG_ACX, "acx slot");
 
392
 
 
393
        slot = kzalloc(sizeof(*slot), GFP_KERNEL);
 
394
        if (!slot) {
 
395
                ret = -ENOMEM;
 
396
                goto out;
 
397
        }
 
398
 
 
399
        slot->wone_index = STATION_WONE_INDEX;
 
400
        slot->slot_time = slot_time;
 
401
 
 
402
        ret = wl1251_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
 
403
        if (ret < 0) {
 
404
                wl1251_warning("failed to set slot time: %d", ret);
 
405
                goto out;
 
406
        }
 
407
 
 
408
out:
 
409
        kfree(slot);
 
410
        return ret;
 
411
}
 
412
 
 
413
int wl1251_acx_group_address_tbl(struct wl1251 *wl)
 
414
{
 
415
        struct acx_dot11_grp_addr_tbl *acx;
 
416
        int ret;
 
417
 
 
418
        wl1251_debug(DEBUG_ACX, "acx group address tbl");
 
419
 
 
420
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
421
        if (!acx) {
 
422
                ret = -ENOMEM;
 
423
                goto out;
 
424
        }
 
425
 
 
426
        /* MAC filtering */
 
427
        acx->enabled = 0;
 
428
        acx->num_groups = 0;
 
429
        memset(acx->mac_table, 0, ADDRESS_GROUP_MAX_LEN);
 
430
 
 
431
        ret = wl1251_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
 
432
                                   acx, sizeof(*acx));
 
433
        if (ret < 0) {
 
434
                wl1251_warning("failed to set group addr table: %d", ret);
 
435
                goto out;
 
436
        }
 
437
 
 
438
out:
 
439
        kfree(acx);
 
440
        return ret;
 
441
}
 
442
 
 
443
int wl1251_acx_service_period_timeout(struct wl1251 *wl)
 
444
{
 
445
        struct acx_rx_timeout *rx_timeout;
 
446
        int ret;
 
447
 
 
448
        rx_timeout = kzalloc(sizeof(*rx_timeout), GFP_KERNEL);
 
449
        if (!rx_timeout) {
 
450
                ret = -ENOMEM;
 
451
                goto out;
 
452
        }
 
453
 
 
454
        wl1251_debug(DEBUG_ACX, "acx service period timeout");
 
455
 
 
456
        rx_timeout->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
 
457
        rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_DEF;
 
458
 
 
459
        ret = wl1251_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
 
460
                                   rx_timeout, sizeof(*rx_timeout));
 
461
        if (ret < 0) {
 
462
                wl1251_warning("failed to set service period timeout: %d",
 
463
                               ret);
 
464
                goto out;
 
465
        }
 
466
 
 
467
out:
 
468
        kfree(rx_timeout);
 
469
        return ret;
 
470
}
 
471
 
 
472
int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold)
 
473
{
 
474
        struct acx_rts_threshold *rts;
 
475
        int ret;
 
476
 
 
477
        wl1251_debug(DEBUG_ACX, "acx rts threshold");
 
478
 
 
479
        rts = kzalloc(sizeof(*rts), GFP_KERNEL);
 
480
        if (!rts) {
 
481
                ret = -ENOMEM;
 
482
                goto out;
 
483
        }
 
484
 
 
485
        rts->threshold = rts_threshold;
 
486
 
 
487
        ret = wl1251_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
 
488
        if (ret < 0) {
 
489
                wl1251_warning("failed to set rts threshold: %d", ret);
 
490
                goto out;
 
491
        }
 
492
 
 
493
out:
 
494
        kfree(rts);
 
495
        return ret;
 
496
}
 
497
 
 
498
int wl1251_acx_beacon_filter_opt(struct wl1251 *wl, bool enable_filter)
 
499
{
 
500
        struct acx_beacon_filter_option *beacon_filter;
 
501
        int ret;
 
502
 
 
503
        wl1251_debug(DEBUG_ACX, "acx beacon filter opt");
 
504
 
 
505
        beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
 
506
        if (!beacon_filter) {
 
507
                ret = -ENOMEM;
 
508
                goto out;
 
509
        }
 
510
 
 
511
        beacon_filter->enable = enable_filter;
 
512
        beacon_filter->max_num_beacons = 0;
 
513
 
 
514
        ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
 
515
                                   beacon_filter, sizeof(*beacon_filter));
 
516
        if (ret < 0) {
 
517
                wl1251_warning("failed to set beacon filter opt: %d", ret);
 
518
                goto out;
 
519
        }
 
520
 
 
521
out:
 
522
        kfree(beacon_filter);
 
523
        return ret;
 
524
}
 
525
 
 
526
int wl1251_acx_beacon_filter_table(struct wl1251 *wl)
 
527
{
 
528
        struct acx_beacon_filter_ie_table *ie_table;
 
529
        int idx = 0;
 
530
        int ret;
 
531
 
 
532
        wl1251_debug(DEBUG_ACX, "acx beacon filter table");
 
533
 
 
534
        ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
 
535
        if (!ie_table) {
 
536
                ret = -ENOMEM;
 
537
                goto out;
 
538
        }
 
539
 
 
540
        /* configure default beacon pass-through rules */
 
541
        ie_table->num_ie = 1;
 
542
        ie_table->table[idx++] = BEACON_FILTER_IE_ID_CHANNEL_SWITCH_ANN;
 
543
        ie_table->table[idx++] = BEACON_RULE_PASS_ON_APPEARANCE;
 
544
 
 
545
        ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
 
546
                                   ie_table, sizeof(*ie_table));
 
547
        if (ret < 0) {
 
548
                wl1251_warning("failed to set beacon filter table: %d", ret);
 
549
                goto out;
 
550
        }
 
551
 
 
552
out:
 
553
        kfree(ie_table);
 
554
        return ret;
 
555
}
 
556
 
 
557
int wl1251_acx_conn_monit_params(struct wl1251 *wl)
 
558
{
 
559
        struct acx_conn_monit_params *acx;
 
560
        int ret;
 
561
 
 
562
        wl1251_debug(DEBUG_ACX, "acx connection monitor parameters");
 
563
 
 
564
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
565
        if (!acx) {
 
566
                ret = -ENOMEM;
 
567
                goto out;
 
568
        }
 
569
 
 
570
        acx->synch_fail_thold = SYNCH_FAIL_DEFAULT_THRESHOLD;
 
571
        acx->bss_lose_timeout = NO_BEACON_DEFAULT_TIMEOUT;
 
572
 
 
573
        ret = wl1251_cmd_configure(wl, ACX_CONN_MONIT_PARAMS,
 
574
                                   acx, sizeof(*acx));
 
575
        if (ret < 0) {
 
576
                wl1251_warning("failed to set connection monitor "
 
577
                               "parameters: %d", ret);
 
578
                goto out;
 
579
        }
 
580
 
 
581
out:
 
582
        kfree(acx);
 
583
        return ret;
 
584
}
 
585
 
 
586
int wl1251_acx_sg_enable(struct wl1251 *wl)
 
587
{
 
588
        struct acx_bt_wlan_coex *pta;
 
589
        int ret;
 
590
 
 
591
        wl1251_debug(DEBUG_ACX, "acx sg enable");
 
592
 
 
593
        pta = kzalloc(sizeof(*pta), GFP_KERNEL);
 
594
        if (!pta) {
 
595
                ret = -ENOMEM;
 
596
                goto out;
 
597
        }
 
598
 
 
599
        pta->enable = SG_ENABLE;
 
600
 
 
601
        ret = wl1251_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
 
602
        if (ret < 0) {
 
603
                wl1251_warning("failed to set softgemini enable: %d", ret);
 
604
                goto out;
 
605
        }
 
606
 
 
607
out:
 
608
        kfree(pta);
 
609
        return ret;
 
610
}
 
611
 
 
612
int wl1251_acx_sg_cfg(struct wl1251 *wl)
 
613
{
 
614
        struct acx_bt_wlan_coex_param *param;
 
615
        int ret;
 
616
 
 
617
        wl1251_debug(DEBUG_ACX, "acx sg cfg");
 
618
 
 
619
        param = kzalloc(sizeof(*param), GFP_KERNEL);
 
620
        if (!param) {
 
621
                ret = -ENOMEM;
 
622
                goto out;
 
623
        }
 
624
 
 
625
        /* BT-WLAN coext parameters */
 
626
        param->min_rate = RATE_INDEX_24MBPS;
 
627
        param->bt_hp_max_time = PTA_BT_HP_MAXTIME_DEF;
 
628
        param->wlan_hp_max_time = PTA_WLAN_HP_MAX_TIME_DEF;
 
629
        param->sense_disable_timer = PTA_SENSE_DISABLE_TIMER_DEF;
 
630
        param->rx_time_bt_hp = PTA_PROTECTIVE_RX_TIME_DEF;
 
631
        param->tx_time_bt_hp = PTA_PROTECTIVE_TX_TIME_DEF;
 
632
        param->rx_time_bt_hp_fast = PTA_PROTECTIVE_RX_TIME_FAST_DEF;
 
633
        param->tx_time_bt_hp_fast = PTA_PROTECTIVE_TX_TIME_FAST_DEF;
 
634
        param->wlan_cycle_fast = PTA_CYCLE_TIME_FAST_DEF;
 
635
        param->bt_anti_starvation_period = PTA_ANTI_STARVE_PERIOD_DEF;
 
636
        param->next_bt_lp_packet = PTA_TIMEOUT_NEXT_BT_LP_PACKET_DEF;
 
637
        param->wake_up_beacon = PTA_TIME_BEFORE_BEACON_DEF;
 
638
        param->hp_dm_max_guard_time = PTA_HPDM_MAX_TIME_DEF;
 
639
        param->next_wlan_packet = PTA_TIME_OUT_NEXT_WLAN_DEF;
 
640
        param->antenna_type = PTA_ANTENNA_TYPE_DEF;
 
641
        param->signal_type = PTA_SIGNALING_TYPE_DEF;
 
642
        param->afh_leverage_on = PTA_AFH_LEVERAGE_ON_DEF;
 
643
        param->quiet_cycle_num = PTA_NUMBER_QUIET_CYCLE_DEF;
 
644
        param->max_cts = PTA_MAX_NUM_CTS_DEF;
 
645
        param->wlan_packets_num = PTA_NUMBER_OF_WLAN_PACKETS_DEF;
 
646
        param->bt_packets_num = PTA_NUMBER_OF_BT_PACKETS_DEF;
 
647
        param->missed_rx_avalanche = PTA_RX_FOR_AVALANCHE_DEF;
 
648
        param->wlan_elp_hp = PTA_ELP_HP_DEF;
 
649
        param->bt_anti_starvation_cycles = PTA_ANTI_STARVE_NUM_CYCLE_DEF;
 
650
        param->ack_mode_dual_ant = PTA_ACK_MODE_DEF;
 
651
        param->pa_sd_enable = PTA_ALLOW_PA_SD_DEF;
 
652
        param->pta_auto_mode_enable = PTA_AUTO_MODE_NO_CTS_DEF;
 
653
        param->bt_hp_respected_num = PTA_BT_HP_RESPECTED_DEF;
 
654
 
 
655
        ret = wl1251_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
 
656
        if (ret < 0) {
 
657
                wl1251_warning("failed to set sg config: %d", ret);
 
658
                goto out;
 
659
        }
 
660
 
 
661
out:
 
662
        kfree(param);
 
663
        return ret;
 
664
}
 
665
 
 
666
int wl1251_acx_cca_threshold(struct wl1251 *wl)
 
667
{
 
668
        struct acx_energy_detection *detection;
 
669
        int ret;
 
670
 
 
671
        wl1251_debug(DEBUG_ACX, "acx cca threshold");
 
672
 
 
673
        detection = kzalloc(sizeof(*detection), GFP_KERNEL);
 
674
        if (!detection) {
 
675
                ret = -ENOMEM;
 
676
                goto out;
 
677
        }
 
678
 
 
679
        detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D;
 
680
        detection->tx_energy_detection = 0;
 
681
 
 
682
        ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
 
683
                                   detection, sizeof(*detection));
 
684
        if (ret < 0) {
 
685
                wl1251_warning("failed to set cca threshold: %d", ret);
 
686
                return ret;
 
687
        }
 
688
 
 
689
out:
 
690
        kfree(detection);
 
691
        return ret;
 
692
}
 
693
 
 
694
int wl1251_acx_bcn_dtim_options(struct wl1251 *wl)
 
695
{
 
696
        struct acx_beacon_broadcast *bb;
 
697
        int ret;
 
698
 
 
699
        wl1251_debug(DEBUG_ACX, "acx bcn dtim options");
 
700
 
 
701
        bb = kzalloc(sizeof(*bb), GFP_KERNEL);
 
702
        if (!bb) {
 
703
                ret = -ENOMEM;
 
704
                goto out;
 
705
        }
 
706
 
 
707
        bb->beacon_rx_timeout = BCN_RX_TIMEOUT_DEF_VALUE;
 
708
        bb->broadcast_timeout = BROADCAST_RX_TIMEOUT_DEF_VALUE;
 
709
        bb->rx_broadcast_in_ps = RX_BROADCAST_IN_PS_DEF_VALUE;
 
710
        bb->ps_poll_threshold = CONSECUTIVE_PS_POLL_FAILURE_DEF;
 
711
 
 
712
        ret = wl1251_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
 
713
        if (ret < 0) {
 
714
                wl1251_warning("failed to set rx config: %d", ret);
 
715
                goto out;
 
716
        }
 
717
 
 
718
out:
 
719
        kfree(bb);
 
720
        return ret;
 
721
}
 
722
 
 
723
int wl1251_acx_aid(struct wl1251 *wl, u16 aid)
 
724
{
 
725
        struct acx_aid *acx_aid;
 
726
        int ret;
 
727
 
 
728
        wl1251_debug(DEBUG_ACX, "acx aid");
 
729
 
 
730
        acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
 
731
        if (!acx_aid) {
 
732
                ret = -ENOMEM;
 
733
                goto out;
 
734
        }
 
735
 
 
736
        acx_aid->aid = aid;
 
737
 
 
738
        ret = wl1251_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
 
739
        if (ret < 0) {
 
740
                wl1251_warning("failed to set aid: %d", ret);
 
741
                goto out;
 
742
        }
 
743
 
 
744
out:
 
745
        kfree(acx_aid);
 
746
        return ret;
 
747
}
 
748
 
 
749
int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask)
 
750
{
 
751
        struct acx_event_mask *mask;
 
752
        int ret;
 
753
 
 
754
        wl1251_debug(DEBUG_ACX, "acx event mbox mask");
 
755
 
 
756
        mask = kzalloc(sizeof(*mask), GFP_KERNEL);
 
757
        if (!mask) {
 
758
                ret = -ENOMEM;
 
759
                goto out;
 
760
        }
 
761
 
 
762
        /* high event mask is unused */
 
763
        mask->high_event_mask = 0xffffffff;
 
764
 
 
765
        mask->event_mask = event_mask;
 
766
 
 
767
        ret = wl1251_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
 
768
                                   mask, sizeof(*mask));
 
769
        if (ret < 0) {
 
770
                wl1251_warning("failed to set acx_event_mbox_mask: %d", ret);
 
771
                goto out;
 
772
        }
 
773
 
 
774
out:
 
775
        kfree(mask);
 
776
        return ret;
 
777
}
 
778
 
 
779
int wl1251_acx_low_rssi(struct wl1251 *wl, s8 threshold, u8 weight,
 
780
                        u8 depth, enum wl1251_acx_low_rssi_type type)
 
781
{
 
782
        struct acx_low_rssi *rssi;
 
783
        int ret;
 
784
 
 
785
        wl1251_debug(DEBUG_ACX, "acx low rssi");
 
786
 
 
787
        rssi = kzalloc(sizeof(*rssi), GFP_KERNEL);
 
788
        if (!rssi)
 
789
                return -ENOMEM;
 
790
 
 
791
        rssi->threshold = threshold;
 
792
        rssi->weight = weight;
 
793
        rssi->depth = depth;
 
794
        rssi->type = type;
 
795
 
 
796
        ret = wl1251_cmd_configure(wl, ACX_LOW_RSSI, rssi, sizeof(*rssi));
 
797
        if (ret < 0)
 
798
                wl1251_warning("failed to set low rssi threshold: %d", ret);
 
799
 
 
800
        kfree(rssi);
 
801
        return ret;
 
802
}
 
803
 
 
804
int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble)
 
805
{
 
806
        struct acx_preamble *acx;
 
807
        int ret;
 
808
 
 
809
        wl1251_debug(DEBUG_ACX, "acx_set_preamble");
 
810
 
 
811
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
812
        if (!acx) {
 
813
                ret = -ENOMEM;
 
814
                goto out;
 
815
        }
 
816
 
 
817
        acx->preamble = preamble;
 
818
 
 
819
        ret = wl1251_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
 
820
        if (ret < 0) {
 
821
                wl1251_warning("Setting of preamble failed: %d", ret);
 
822
                goto out;
 
823
        }
 
824
 
 
825
out:
 
826
        kfree(acx);
 
827
        return ret;
 
828
}
 
829
 
 
830
int wl1251_acx_cts_protect(struct wl1251 *wl,
 
831
                           enum acx_ctsprotect_type ctsprotect)
 
832
{
 
833
        struct acx_ctsprotect *acx;
 
834
        int ret;
 
835
 
 
836
        wl1251_debug(DEBUG_ACX, "acx_set_ctsprotect");
 
837
 
 
838
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
839
        if (!acx) {
 
840
                ret = -ENOMEM;
 
841
                goto out;
 
842
        }
 
843
 
 
844
        acx->ctsprotect = ctsprotect;
 
845
 
 
846
        ret = wl1251_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
 
847
        if (ret < 0) {
 
848
                wl1251_warning("Setting of ctsprotect failed: %d", ret);
 
849
                goto out;
 
850
        }
 
851
 
 
852
out:
 
853
        kfree(acx);
 
854
        return ret;
 
855
}
 
856
 
 
857
int wl1251_acx_tsf_info(struct wl1251 *wl, u64 *mactime)
 
858
{
 
859
        struct acx_tsf_info *tsf_info;
 
860
        int ret;
 
861
 
 
862
        tsf_info = kzalloc(sizeof(*tsf_info), GFP_KERNEL);
 
863
        if (!tsf_info) {
 
864
                ret = -ENOMEM;
 
865
                goto out;
 
866
        }
 
867
 
 
868
        ret = wl1251_cmd_interrogate(wl, ACX_TSF_INFO,
 
869
                                     tsf_info, sizeof(*tsf_info));
 
870
        if (ret < 0) {
 
871
                wl1251_warning("ACX_FW_REV interrogate failed");
 
872
                goto out;
 
873
        }
 
874
 
 
875
        *mactime = tsf_info->current_tsf_lsb |
 
876
                (tsf_info->current_tsf_msb << 31);
 
877
 
 
878
out:
 
879
        kfree(tsf_info);
 
880
        return ret;
 
881
}
 
882
 
 
883
int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats)
 
884
{
 
885
        int ret;
 
886
 
 
887
        wl1251_debug(DEBUG_ACX, "acx statistics");
 
888
 
 
889
        ret = wl1251_cmd_interrogate(wl, ACX_STATISTICS, stats,
 
890
                                     sizeof(*stats));
 
891
        if (ret < 0) {
 
892
                wl1251_warning("acx statistics failed: %d", ret);
 
893
                return -ENOMEM;
 
894
        }
 
895
 
 
896
        return 0;
 
897
}
 
898
 
 
899
int wl1251_acx_rate_policies(struct wl1251 *wl)
 
900
{
 
901
        struct acx_rate_policy *acx;
 
902
        int ret = 0;
 
903
 
 
904
        wl1251_debug(DEBUG_ACX, "acx rate policies");
 
905
 
 
906
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
907
 
 
908
        if (!acx) {
 
909
                ret = -ENOMEM;
 
910
                goto out;
 
911
        }
 
912
 
 
913
        /* configure one default (one-size-fits-all) rate class */
 
914
        acx->rate_class_cnt = 1;
 
915
        acx->rate_class[0].enabled_rates = ACX_RATE_MASK_UNSPECIFIED;
 
916
        acx->rate_class[0].short_retry_limit = ACX_RATE_RETRY_LIMIT;
 
917
        acx->rate_class[0].long_retry_limit = ACX_RATE_RETRY_LIMIT;
 
918
        acx->rate_class[0].aflags = 0;
 
919
 
 
920
        ret = wl1251_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
 
921
        if (ret < 0) {
 
922
                wl1251_warning("Setting of rate policies failed: %d", ret);
 
923
                goto out;
 
924
        }
 
925
 
 
926
out:
 
927
        kfree(acx);
 
928
        return ret;
 
929
}
 
930
 
 
931
int wl1251_acx_mem_cfg(struct wl1251 *wl)
 
932
{
 
933
        struct wl1251_acx_config_memory *mem_conf;
 
934
        int ret, i;
 
935
 
 
936
        wl1251_debug(DEBUG_ACX, "acx mem cfg");
 
937
 
 
938
        mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
 
939
        if (!mem_conf) {
 
940
                ret = -ENOMEM;
 
941
                goto out;
 
942
        }
 
943
 
 
944
        /* memory config */
 
945
        mem_conf->mem_config.num_stations = cpu_to_le16(DEFAULT_NUM_STATIONS);
 
946
        mem_conf->mem_config.rx_mem_block_num = 35;
 
947
        mem_conf->mem_config.tx_min_mem_block_num = 64;
 
948
        mem_conf->mem_config.num_tx_queues = MAX_TX_QUEUES;
 
949
        mem_conf->mem_config.host_if_options = HOSTIF_PKT_RING;
 
950
        mem_conf->mem_config.num_ssid_profiles = 1;
 
951
        mem_conf->mem_config.debug_buffer_size =
 
952
                cpu_to_le16(TRACE_BUFFER_MAX_SIZE);
 
953
 
 
954
        /* RX queue config */
 
955
        mem_conf->rx_queue_config.dma_address = 0;
 
956
        mem_conf->rx_queue_config.num_descs = ACX_RX_DESC_DEF;
 
957
        mem_conf->rx_queue_config.priority = DEFAULT_RXQ_PRIORITY;
 
958
        mem_conf->rx_queue_config.type = DEFAULT_RXQ_TYPE;
 
959
 
 
960
        /* TX queue config */
 
961
        for (i = 0; i < MAX_TX_QUEUES; i++) {
 
962
                mem_conf->tx_queue_config[i].num_descs = ACX_TX_DESC_DEF;
 
963
                mem_conf->tx_queue_config[i].attributes = i;
 
964
        }
 
965
 
 
966
        ret = wl1251_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
 
967
                                   sizeof(*mem_conf));
 
968
        if (ret < 0) {
 
969
                wl1251_warning("wl1251 mem config failed: %d", ret);
 
970
                goto out;
 
971
        }
 
972
 
 
973
out:
 
974
        kfree(mem_conf);
 
975
        return ret;
 
976
}
 
977
 
 
978
int wl1251_acx_wr_tbtt_and_dtim(struct wl1251 *wl, u16 tbtt, u8 dtim)
 
979
{
 
980
        struct wl1251_acx_wr_tbtt_and_dtim *acx;
 
981
        int ret;
 
982
 
 
983
        wl1251_debug(DEBUG_ACX, "acx tbtt and dtim");
 
984
 
 
985
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
986
        if (!acx) {
 
987
                ret = -ENOMEM;
 
988
                goto out;
 
989
        }
 
990
 
 
991
        acx->tbtt = tbtt;
 
992
        acx->dtim = dtim;
 
993
 
 
994
        ret = wl1251_cmd_configure(wl, ACX_WR_TBTT_AND_DTIM,
 
995
                                   acx, sizeof(*acx));
 
996
        if (ret < 0) {
 
997
                wl1251_warning("failed to set tbtt and dtim: %d", ret);
 
998
                goto out;
 
999
        }
 
1000
 
 
1001
out:
 
1002
        kfree(acx);
 
1003
        return ret;
 
1004
}
 
1005
 
 
1006
int wl1251_acx_bet_enable(struct wl1251 *wl, enum wl1251_acx_bet_mode mode,
 
1007
                          u8 max_consecutive)
 
1008
{
 
1009
        struct wl1251_acx_bet_enable *acx;
 
1010
        int ret;
 
1011
 
 
1012
        wl1251_debug(DEBUG_ACX, "acx bet enable");
 
1013
 
 
1014
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
1015
        if (!acx) {
 
1016
                ret = -ENOMEM;
 
1017
                goto out;
 
1018
        }
 
1019
 
 
1020
        acx->enable = mode;
 
1021
        acx->max_consecutive = max_consecutive;
 
1022
 
 
1023
        ret = wl1251_cmd_configure(wl, ACX_BET_ENABLE, acx, sizeof(*acx));
 
1024
        if (ret < 0) {
 
1025
                wl1251_warning("wl1251 acx bet enable failed: %d", ret);
 
1026
                goto out;
 
1027
        }
 
1028
 
 
1029
out:
 
1030
        kfree(acx);
 
1031
        return ret;
 
1032
}
 
1033
 
 
1034
int wl1251_acx_ac_cfg(struct wl1251 *wl, u8 ac, u8 cw_min, u16 cw_max,
 
1035
                      u8 aifs, u16 txop)
 
1036
{
 
1037
        struct wl1251_acx_ac_cfg *acx;
 
1038
        int ret = 0;
 
1039
 
 
1040
        wl1251_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d "
 
1041
                     "aifs %d txop %d", ac, cw_min, cw_max, aifs, txop);
 
1042
 
 
1043
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
1044
 
 
1045
        if (!acx) {
 
1046
                ret = -ENOMEM;
 
1047
                goto out;
 
1048
        }
 
1049
 
 
1050
        acx->ac = ac;
 
1051
        acx->cw_min = cw_min;
 
1052
        acx->cw_max = cw_max;
 
1053
        acx->aifsn = aifs;
 
1054
        acx->txop_limit = txop;
 
1055
 
 
1056
        ret = wl1251_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx));
 
1057
        if (ret < 0) {
 
1058
                wl1251_warning("acx ac cfg failed: %d", ret);
 
1059
                goto out;
 
1060
        }
 
1061
 
 
1062
out:
 
1063
        kfree(acx);
 
1064
        return ret;
 
1065
}
 
1066
 
 
1067
int wl1251_acx_tid_cfg(struct wl1251 *wl, u8 queue,
 
1068
                       enum wl1251_acx_channel_type type,
 
1069
                       u8 tsid, enum wl1251_acx_ps_scheme ps_scheme,
 
1070
                       enum wl1251_acx_ack_policy ack_policy)
 
1071
{
 
1072
        struct wl1251_acx_tid_cfg *acx;
 
1073
        int ret = 0;
 
1074
 
 
1075
        wl1251_debug(DEBUG_ACX, "acx tid cfg %d type %d tsid %d "
 
1076
                     "ps_scheme %d ack_policy %d", queue, type, tsid,
 
1077
                     ps_scheme, ack_policy);
 
1078
 
 
1079
        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
1080
 
 
1081
        if (!acx) {
 
1082
                ret = -ENOMEM;
 
1083
                goto out;
 
1084
        }
 
1085
 
 
1086
        acx->queue = queue;
 
1087
        acx->type = type;
 
1088
        acx->tsid = tsid;
 
1089
        acx->ps_scheme = ps_scheme;
 
1090
        acx->ack_policy = ack_policy;
 
1091
 
 
1092
        ret = wl1251_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx));
 
1093
        if (ret < 0) {
 
1094
                wl1251_warning("acx tid cfg failed: %d", ret);
 
1095
                goto out;
 
1096
        }
 
1097
 
 
1098
out:
 
1099
        kfree(acx);
 
1100
        return ret;
 
1101
}