← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/ath6kl/wmi/wmi.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/ath6kl/wmi/wmi.c
25
25
 
26
26
#include <a_config.h>
27
27
#include <athdefs.h>
28
 
#include <a_types.h>
29
28
#include <a_osapi.h>
30
29
#include "htc.h"
31
30
#include "htc_api.h"
35
34
#include <ieee80211.h>
36
35
#include <ieee80211_node.h>
37
36
#include "dset_api.h"
38
 
#include "gpio_api.h"
39
37
#include "wmi_host.h"
40
38
#include "a_drv.h"
41
39
#include "a_drv_api.h"
48
46
 
49
47
#ifdef ATH_DEBUG_MODULE
50
48
 
51
 
static ATH_DEBUG_MASK_DESCRIPTION wmi_debug_desc[] = {
 
49
static struct ath_debug_mask_description wmi_debug_desc[] = {
52
50
    { ATH_DEBUG_WMI , "General WMI Tracing"},
53
51
};
54
52
 
70
68
#define A_DPRINTF   AR_DEBUG_PRINTF
71
69
#endif
72
70
 
73
 
static A_STATUS wmi_ready_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
74
 
 
75
 
static A_STATUS wmi_connect_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
76
 
                                     int len);
77
 
static A_STATUS wmi_disconnect_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
78
 
                                        int len);
79
 
 
80
 
static A_STATUS wmi_tkip_micerr_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
81
 
                                        int len);
82
 
static A_STATUS wmi_bssInfo_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
83
 
                                     int len);
84
 
static A_STATUS wmi_opt_frame_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
71
static int wmi_ready_event_rx(struct wmi_t *wmip, u8 *datap, int len);
 
72
 
 
73
static int wmi_connect_event_rx(struct wmi_t *wmip, u8 *datap,
 
74
                                     int len);
 
75
static int wmi_disconnect_event_rx(struct wmi_t *wmip, u8 *datap,
 
76
                                        int len);
 
77
 
 
78
static int wmi_tkip_micerr_event_rx(struct wmi_t *wmip, u8 *datap,
 
79
                                        int len);
 
80
static int wmi_bssInfo_event_rx(struct wmi_t *wmip, u8 *datap,
 
81
                                     int len);
 
82
static int wmi_opt_frame_event_rx(struct wmi_t *wmip, u8 *datap,
85
83
                                       int len);
86
 
static A_STATUS wmi_pstream_timeout_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
84
static int wmi_pstream_timeout_event_rx(struct wmi_t *wmip, u8 *datap,
87
85
                                     int len);
88
 
static A_STATUS wmi_sync_point(struct wmi_t *wmip);
 
86
static int wmi_sync_point(struct wmi_t *wmip);
89
87
 
90
 
static A_STATUS wmi_bitrate_reply_rx(struct wmi_t *wmip, A_UINT8 *datap,
91
 
                                     int len);
92
 
static A_STATUS wmi_ratemask_reply_rx(struct wmi_t *wmip, A_UINT8 *datap,
93
 
                                     int len);
94
 
static A_STATUS wmi_channelList_reply_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
88
static int wmi_bitrate_reply_rx(struct wmi_t *wmip, u8 *datap,
 
89
                                     int len);
 
90
static int wmi_ratemask_reply_rx(struct wmi_t *wmip, u8 *datap,
 
91
                                     int len);
 
92
static int wmi_channelList_reply_rx(struct wmi_t *wmip, u8 *datap,
95
93
                                         int len);
96
 
static A_STATUS wmi_regDomain_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
94
static int wmi_regDomain_event_rx(struct wmi_t *wmip, u8 *datap,
97
95
                                       int len);
98
 
static A_STATUS wmi_txPwr_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
99
 
static A_STATUS wmi_neighborReport_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
96
static int wmi_txPwr_reply_rx(struct wmi_t *wmip, u8 *datap, int len);
 
97
static int wmi_neighborReport_event_rx(struct wmi_t *wmip, u8 *datap,
100
98
                                             int len);
101
99
 
102
 
static A_STATUS wmi_dset_open_req_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
100
static int wmi_dset_open_req_rx(struct wmi_t *wmip, u8 *datap,
103
101
                                     int len);
104
102
#ifdef CONFIG_HOST_DSET_SUPPORT
105
 
static A_STATUS wmi_dset_close_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
106
 
static A_STATUS wmi_dset_data_req_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
103
static int wmi_dset_close_rx(struct wmi_t *wmip, u8 *datap, int len);
 
104
static int wmi_dset_data_req_rx(struct wmi_t *wmip, u8 *datap,
107
105
                                     int len);
108
106
#endif /* CONFIG_HOST_DSET_SUPPORT */
109
107
 
110
108
 
111
 
static A_STATUS wmi_scanComplete_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
109
static int wmi_scanComplete_rx(struct wmi_t *wmip, u8 *datap,
112
110
                                     int len);
113
 
static A_STATUS wmi_errorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
114
 
static A_STATUS wmi_statsEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
115
 
static A_STATUS wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
116
 
static A_STATUS wmi_hbChallengeResp_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
117
 
static A_STATUS wmi_reportErrorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
118
 
static A_STATUS wmi_cac_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
119
 
static A_STATUS wmi_channel_change_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
120
 
static A_STATUS wmi_roam_tbl_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
121
 
                                      int len);
122
 
static A_STATUS wmi_roam_data_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
123
 
                                      int len);
124
 
static A_STATUS wmi_get_wow_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
125
 
                                      int len);
126
 
static A_STATUS
127
 
wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
128
 
 
129
 
static A_STATUS
130
 
wmi_set_params_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
131
 
 
132
 
static A_STATUS
133
 
wmi_acm_reject_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
134
 
 
135
 
#ifdef CONFIG_HOST_GPIO_SUPPORT
136
 
static A_STATUS wmi_gpio_intr_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
137
 
static A_STATUS wmi_gpio_data_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
138
 
static A_STATUS wmi_gpio_ack_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
139
 
#endif /* CONFIG_HOST_GPIO_SUPPORT */
 
111
static int wmi_errorEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
112
static int wmi_statsEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
113
static int wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
114
static int wmi_hbChallengeResp_rx(struct wmi_t *wmip, u8 *datap, int len);
 
115
static int wmi_reportErrorEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
116
static int wmi_cac_event_rx(struct wmi_t *wmip, u8 *datap, int len);
 
117
static int wmi_channel_change_event_rx(struct wmi_t *wmip, u8 *datap, int len);
 
118
static int wmi_roam_tbl_event_rx(struct wmi_t *wmip, u8 *datap,
 
119
                                      int len);
 
120
static int wmi_roam_data_event_rx(struct wmi_t *wmip, u8 *datap,
 
121
                                      int len);
 
122
static int wmi_get_wow_list_event_rx(struct wmi_t *wmip, u8 *datap,
 
123
                                      int len);
 
124
static int
 
125
wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, u8 *datap, u32 len);
 
126
 
 
127
static int
 
128
wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, u32 len);
 
129
 
140
130
 
141
131
#ifdef CONFIG_HOST_TCMD_SUPPORT
142
 
static A_STATUS
143
 
wmi_tcmd_test_report_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
 
132
static int
 
133
wmi_tcmd_test_report_rx(struct wmi_t *wmip, u8 *datap, int len);
144
134
#endif
145
135
 
146
 
static A_STATUS
147
 
wmi_txRetryErrEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
148
 
 
149
 
static A_STATUS
150
 
wmi_snrThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
151
 
 
152
 
static A_STATUS
153
 
wmi_lqThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
154
 
 
155
 
static A_BOOL
156
 
wmi_is_bitrate_index_valid(struct wmi_t *wmip, A_INT32 rateIndex);
157
 
 
158
 
static A_STATUS
159
 
wmi_aplistEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
160
 
 
161
 
static A_STATUS
162
 
wmi_dbglog_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
163
 
 
164
 
static A_STATUS wmi_keepalive_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
165
 
 
166
 
A_STATUS wmi_cmd_send_xtnd(struct wmi_t *wmip, void *osbuf, WMIX_COMMAND_ID cmdId,
 
136
static int
 
137
wmi_txRetryErrEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
138
 
 
139
static int
 
140
wmi_snrThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
141
 
 
142
static int
 
143
wmi_lqThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
144
 
 
145
static bool
 
146
wmi_is_bitrate_index_valid(struct wmi_t *wmip, s32 rateIndex);
 
147
 
 
148
static int
 
149
wmi_aplistEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
 
150
 
 
151
static int
 
152
wmi_dbglog_event_rx(struct wmi_t *wmip, u8 *datap, int len);
 
153
 
 
154
static int wmi_keepalive_reply_rx(struct wmi_t *wmip, u8 *datap, int len);
 
155
 
 
156
int wmi_cmd_send_xtnd(struct wmi_t *wmip, void *osbuf, WMIX_COMMAND_ID cmdId,
167
157
                  WMI_SYNC_FLAG syncflag);
168
158
 
169
 
A_UINT8 ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, A_UINT32 size);
170
 
A_UINT8 ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, A_UINT32 size);
 
159
u8 ar6000_get_upper_threshold(s16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, u32 size);
 
160
u8 ar6000_get_lower_threshold(s16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, u32 size);
171
161
 
172
162
void wmi_cache_configure_rssithreshold(struct wmi_t *wmip, WMI_RSSI_THRESHOLD_PARAMS_CMD *rssiCmd);
173
163
void wmi_cache_configure_snrthreshold(struct wmi_t *wmip, WMI_SNR_THRESHOLD_PARAMS_CMD *snrCmd);
174
 
static A_STATUS wmi_send_rssi_threshold_params(struct wmi_t *wmip,
 
164
static int wmi_send_rssi_threshold_params(struct wmi_t *wmip,
175
165
                              WMI_RSSI_THRESHOLD_PARAMS_CMD *rssiCmd);
176
 
static A_STATUS wmi_send_snr_threshold_params(struct wmi_t *wmip,
 
166
static int wmi_send_snr_threshold_params(struct wmi_t *wmip,
177
167
                             WMI_SNR_THRESHOLD_PARAMS_CMD *snrCmd);
178
168
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
179
 
static A_STATUS
180
 
wmi_prof_count_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
 
169
static int
 
170
wmi_prof_count_rx(struct wmi_t *wmip, u8 *datap, int len);
181
171
#endif /* CONFIG_TARGET_PROFILE_SUPPORT */
182
172
 
183
 
static A_STATUS wmi_pspoll_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
173
static int wmi_pspoll_event_rx(struct wmi_t *wmip, u8 *datap,
184
174
                                     int len);
185
 
static A_STATUS wmi_dtimexpiry_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
175
static int wmi_dtimexpiry_event_rx(struct wmi_t *wmip, u8 *datap,
186
176
                                     int len);
187
177
 
188
 
static A_STATUS wmi_peer_node_event_rx (struct wmi_t *wmip, A_UINT8 *datap,
 
178
static int wmi_peer_node_event_rx (struct wmi_t *wmip, u8 *datap,
189
179
                                        int len);
190
 
#ifdef ATH_AR6K_11N_SUPPORT
191
 
static A_STATUS wmi_addba_req_event_rx(struct wmi_t *, A_UINT8 *, int);
192
 
static A_STATUS wmi_addba_resp_event_rx(struct wmi_t *, A_UINT8 *, int);
193
 
static A_STATUS wmi_delba_req_event_rx(struct wmi_t *, A_UINT8 *, int);
194
 
static A_STATUS wmi_btcoex_config_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
195
 
static A_STATUS wmi_btcoex_stats_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
196
 
#endif
197
 
static A_STATUS wmi_hci_event_rx(struct wmi_t *, A_UINT8 *, int);
 
180
static int wmi_addba_req_event_rx(struct wmi_t *, u8 *, int);
 
181
static int wmi_addba_resp_event_rx(struct wmi_t *, u8 *, int);
 
182
static int wmi_delba_req_event_rx(struct wmi_t *, u8 *, int);
 
183
static int wmi_btcoex_config_event_rx(struct wmi_t *wmip, u8 *datap, int len);
 
184
static int wmi_btcoex_stats_event_rx(struct wmi_t *wmip, u8 *datap, int len);
 
185
static int wmi_hci_event_rx(struct wmi_t *, u8 *, int);
198
186
 
199
187
#ifdef WAPI_ENABLE
200
 
static A_STATUS wmi_wapi_rekey_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
 
188
static int wmi_wapi_rekey_event_rx(struct wmi_t *wmip, u8 *datap,
201
189
                                     int len);
202
190
#endif
203
191
 
212
200
#endif
213
201
 
214
202
int wps_enable;
215
 
static const A_INT32 wmi_rateTable[][2] = {
 
203
static const s32 wmi_rateTable[][2] = {
216
204
  //{W/O SGI, with SGI}
217
205
    {1000, 1000},
218
206
    {2000, 2000},
244
232
    {135000, 150000},
245
233
    {0, 0}};
246
234
 
247
 
#define MODE_A_SUPPORT_RATE_START       ((A_INT32) 4)
248
 
#define MODE_A_SUPPORT_RATE_STOP        ((A_INT32) 11)
 
235
#define MODE_A_SUPPORT_RATE_START       ((s32) 4)
 
236
#define MODE_A_SUPPORT_RATE_STOP        ((s32) 11)
249
237
 
250
238
#define MODE_GONLY_SUPPORT_RATE_START   MODE_A_SUPPORT_RATE_START
251
239
#define MODE_GONLY_SUPPORT_RATE_STOP    MODE_A_SUPPORT_RATE_STOP
252
240
 
253
 
#define MODE_B_SUPPORT_RATE_START       ((A_INT32) 0)
254
 
#define MODE_B_SUPPORT_RATE_STOP        ((A_INT32) 3)
255
 
 
256
 
#define MODE_G_SUPPORT_RATE_START       ((A_INT32) 0)
257
 
#define MODE_G_SUPPORT_RATE_STOP        ((A_INT32) 11)
258
 
 
259
 
#define MODE_GHT20_SUPPORT_RATE_START   ((A_INT32) 0)
260
 
#define MODE_GHT20_SUPPORT_RATE_STOP    ((A_INT32) 19)
 
241
#define MODE_B_SUPPORT_RATE_START       ((s32) 0)
 
242
#define MODE_B_SUPPORT_RATE_STOP        ((s32) 3)
 
243
 
 
244
#define MODE_G_SUPPORT_RATE_START       ((s32) 0)
 
245
#define MODE_G_SUPPORT_RATE_STOP        ((s32) 11)
 
246
 
 
247
#define MODE_GHT20_SUPPORT_RATE_START   ((s32) 0)
 
248
#define MODE_GHT20_SUPPORT_RATE_STOP    ((s32) 19)
261
249
 
262
250
#define MAX_NUMBER_OF_SUPPORT_RATES     (MODE_GHT20_SUPPORT_RATE_STOP + 1)
263
251
 
264
252
/* 802.1d to AC mapping. Refer pg 57 of WMM-test-plan-v1.2 */
265
 
const A_UINT8 up_to_ac[]= {
 
253
const u8 up_to_ac[]= {
266
254
                WMM_AC_BE,
267
255
                WMM_AC_BK,
268
256
                WMM_AC_BK,
273
261
                WMM_AC_VO,
274
262
            };
275
263
 
276
 
#include "athstartpack.h"
277
 
 
278
264
/* This stuff is used when we want a simple layer-3 visibility */
279
265
typedef PREPACK struct _iphdr {
280
 
    A_UINT8     ip_ver_hdrlen;          /* version and hdr length */
281
 
    A_UINT8     ip_tos;                 /* type of service */
282
 
    A_UINT16    ip_len;                 /* total length */
283
 
    A_UINT16    ip_id;                  /* identification */
284
 
    A_INT16     ip_off;                 /* fragment offset field */
 
266
    u8 ip_ver_hdrlen;          /* version and hdr length */
 
267
    u8 ip_tos;                 /* type of service */
 
268
    u16 ip_len;                 /* total length */
 
269
    u16 ip_id;                  /* identification */
 
270
    s16 ip_off;                 /* fragment offset field */
285
271
#define IP_DF 0x4000                    /* dont fragment flag */
286
272
#define IP_MF 0x2000                    /* more fragments flag */
287
273
#define IP_OFFMASK 0x1fff               /* mask for fragmenting bits */
288
 
    A_UINT8     ip_ttl;                 /* time to live */
289
 
    A_UINT8     ip_p;                   /* protocol */
290
 
    A_UINT16    ip_sum;                 /* checksum */
291
 
    A_UINT8     ip_src[4];              /* source and dest address */
292
 
    A_UINT8     ip_dst[4];
 
274
    u8 ip_ttl;                 /* time to live */
 
275
    u8 ip_p;                   /* protocol */
 
276
    u16 ip_sum;                 /* checksum */
 
277
    u8 ip_src[4];              /* source and dest address */
 
278
    u8 ip_dst[4];
293
279
} POSTPACK iphdr;
294
280
 
295
 
#include "athendpack.h"
296
 
 
297
 
static A_INT16 rssi_event_value = 0;
298
 
static A_INT16 snr_event_value = 0;
299
 
 
300
 
A_BOOL is_probe_ssid = FALSE;
 
281
static s16 rssi_event_value = 0;
 
282
static s16 snr_event_value = 0;
 
283
 
 
284
bool is_probe_ssid = false;
301
285
 
302
286
void *
303
287
wmi_init(void *devt)
335
319
void
336
320
wmi_qos_state_init(struct wmi_t *wmip)
337
321
{
338
 
    A_UINT8 i;
 
322
    u8 i;
339
323
 
340
324
    if (wmip == NULL) {
341
325
        return;
381
365
            A_MUTEX_DELETE(&wmip->wmi_lock);
382
366
#endif
383
367
        }
384
 
        A_FREE(wmip);
 
368
        kfree(wmip);
385
369
    }
386
370
}
387
371
 
391
375
 *  Assumes the entire DIX header is contigous and that there is
392
376
 *  enough room in the buffer for a 802.3 mac header and LLC+SNAP headers.
393
377
 */
394
 
A_STATUS
 
378
int
395
379
wmi_dix_2_dot3(struct wmi_t *wmip, void *osbuf)
396
380
{
397
 
    A_UINT8          *datap;
398
 
    A_UINT16         typeorlen;
 
381
    u8 *datap;
 
382
    u16 typeorlen;
399
383
    ATH_MAC_HDR      macHdr;
400
384
    ATH_LLC_SNAP_HDR *llcHdr;
401
385
 
409
393
 
410
394
    datap = A_NETBUF_DATA(osbuf);
411
395
 
412
 
    typeorlen = *(A_UINT16 *)(datap + ATH_MAC_LEN + ATH_MAC_LEN);
 
396
    typeorlen = *(u16 *)(datap + ATH_MAC_LEN + ATH_MAC_LEN);
413
397
 
414
398
    if (!IS_ETHERTYPE(A_BE2CPU16(typeorlen))) {
415
399
        /*
416
400
         * packet is already in 802.3 format - return success
417
401
         */
418
402
        A_DPRINTF(DBG_WMI, (DBGFMT "packet already 802.3\n", DBGARG));
419
 
        return (A_OK);
 
403
        return (0);
420
404
    }
421
405
 
422
406
    /*
423
407
     * Save mac fields and length to be inserted later
424
408
     */
425
 
    A_MEMCPY(macHdr.dstMac, datap, ATH_MAC_LEN);
426
 
    A_MEMCPY(macHdr.srcMac, datap + ATH_MAC_LEN, ATH_MAC_LEN);
 
409
    memcpy(macHdr.dstMac, datap, ATH_MAC_LEN);
 
410
    memcpy(macHdr.srcMac, datap + ATH_MAC_LEN, ATH_MAC_LEN);
427
411
    macHdr.typeOrLen = A_CPU2BE16(A_NETBUF_LEN(osbuf) - sizeof(ATH_MAC_HDR) +
428
412
                                  sizeof(ATH_LLC_SNAP_HDR));
429
413
 
430
414
    /*
431
415
     * Make room for LLC+SNAP headers
432
416
     */
433
 
    if (A_NETBUF_PUSH(osbuf, sizeof(ATH_LLC_SNAP_HDR)) != A_OK) {
 
417
    if (A_NETBUF_PUSH(osbuf, sizeof(ATH_LLC_SNAP_HDR)) != 0) {
434
418
        return A_NO_MEMORY;
435
419
    }
436
420
    datap = A_NETBUF_DATA(osbuf);
437
421
 
438
 
    A_MEMCPY(datap, &macHdr, sizeof (ATH_MAC_HDR));
 
422
    memcpy(datap, &macHdr, sizeof (ATH_MAC_HDR));
439
423
 
440
424
    llcHdr = (ATH_LLC_SNAP_HDR *)(datap + sizeof(ATH_MAC_HDR));
441
425
    llcHdr->dsap      = 0xAA;
446
430
    llcHdr->orgCode[2] = 0x0;
447
431
    llcHdr->etherType = typeorlen;
448
432
 
449
 
    return (A_OK);
 
433
    return (0);
450
434
}
451
435
 
452
 
A_STATUS wmi_meta_add(struct wmi_t *wmip, void *osbuf, A_UINT8 *pVersion,void *pTxMetaS)
 
436
int wmi_meta_add(struct wmi_t *wmip, void *osbuf, u8 *pVersion,void *pTxMetaS)
453
437
{
454
438
    switch(*pVersion){
455
439
        case 0:
456
 
                return (A_OK);
 
440
                return (0);
457
441
        case WMI_META_VERSION_1:
458
442
                {
459
443
                WMI_TX_META_V1     *pV1= NULL;
460
444
                A_ASSERT(osbuf != NULL);
461
 
                if (A_NETBUF_PUSH(osbuf, WMI_MAX_TX_META_SZ) != A_OK) {
 
445
                if (A_NETBUF_PUSH(osbuf, WMI_MAX_TX_META_SZ) != 0) {
462
446
                        return A_NO_MEMORY;
463
447
                }
464
448
 
473
457
                A_ASSERT(pVersion != NULL);
474
458
                /* the version must be used to populate the meta field of the WMI_DATA_HDR */
475
459
                *pVersion = WMI_META_VERSION_1;
476
 
                return (A_OK);
 
460
                return (0);
477
461
                }
478
 
#ifdef CONFIG_CHECKSUM_OFFLOAD
479
462
        case WMI_META_VERSION_2:
480
463
                {
481
464
                WMI_TX_META_V2 *pV2 ;
482
465
                A_ASSERT(osbuf != NULL);
483
 
                if (A_NETBUF_PUSH(osbuf, WMI_MAX_TX_META_SZ) != A_OK) {
 
466
                if (A_NETBUF_PUSH(osbuf, WMI_MAX_TX_META_SZ) != 0) {
484
467
                        return A_NO_MEMORY;
485
468
                }
486
469
                pV2 = (WMI_TX_META_V2 *)A_NETBUF_DATA(osbuf);
487
 
                A_MEMCPY(pV2,(WMI_TX_META_V2 *)pTxMetaS,sizeof(WMI_TX_META_V2));
488
 
                return (A_OK);
 
470
                memcpy(pV2,(WMI_TX_META_V2 *)pTxMetaS,sizeof(WMI_TX_META_V2));
 
471
                return (0);
489
472
                }
490
 
#endif
491
473
        default:
492
 
                return (A_OK);
 
474
                return (0);
493
475
    }
494
476
}
495
477
 
496
478
/* Adds a WMI data header */
497
 
A_STATUS
498
 
wmi_data_hdr_add(struct wmi_t *wmip, void *osbuf, A_UINT8 msgType, A_BOOL bMoreData,
499
 
                    WMI_DATA_HDR_DATA_TYPE data_type,A_UINT8 metaVersion, void *pTxMetaS)
 
479
int
 
480
wmi_data_hdr_add(struct wmi_t *wmip, void *osbuf, u8 msgType, bool bMoreData,
 
481
                    WMI_DATA_HDR_DATA_TYPE data_type,u8 metaVersion, void *pTxMetaS)
500
482
{
501
483
    WMI_DATA_HDR     *dtHdr;
502
 
//    A_UINT8 metaVersion = 0;
503
 
    A_STATUS status;
 
484
//    u8 metaVersion = 0;
 
485
    int status;
504
486
 
505
487
    A_ASSERT(osbuf != NULL);
506
488
 
507
489
    /* adds the meta data field after the wmi data hdr. If metaVersion
508
490
     * is returns 0 then no meta field was added. */
509
 
    if ((status = wmi_meta_add(wmip, osbuf, &metaVersion,pTxMetaS)) != A_OK) {
 
491
    if ((status = wmi_meta_add(wmip, osbuf, &metaVersion,pTxMetaS)) != 0) {
510
492
        return status;
511
493
    }
512
494
 
513
 
    if (A_NETBUF_PUSH(osbuf, sizeof(WMI_DATA_HDR)) != A_OK) {
 
495
    if (A_NETBUF_PUSH(osbuf, sizeof(WMI_DATA_HDR)) != 0) {
514
496
        return A_NO_MEMORY;
515
497
    }
516
498
 
525
507
    }
526
508
 
527
509
    WMI_DATA_HDR_SET_META(dtHdr, metaVersion);
528
 
    //dtHdr->rssi = 0;
529
 
 
530
 
    return (A_OK);
 
510
 
 
511
    dtHdr->info3 = 0;
 
512
 
 
513
    return (0);
531
514
}
532
515
 
533
516
 
534
 
A_UINT8 wmi_implicit_create_pstream(struct wmi_t *wmip, void *osbuf, A_UINT32 layer2Priority, A_BOOL wmmEnabled)
 
517
u8 wmi_implicit_create_pstream(struct wmi_t *wmip, void *osbuf, u32 layer2Priority, bool wmmEnabled)
535
518
{
536
 
    A_UINT8         *datap;
537
 
    A_UINT8         trafficClass = WMM_AC_BE;
538
 
    A_UINT16        ipType = IP_ETHERTYPE;
 
519
    u8 *datap;
 
520
    u8 trafficClass = WMM_AC_BE;
 
521
    u16 ipType = IP_ETHERTYPE;
539
522
    WMI_DATA_HDR    *dtHdr;
540
 
    A_BOOL           streamExists = FALSE;
541
 
    A_UINT8        userPriority;
542
 
    A_UINT32            hdrsize, metasize;
 
523
    u8 streamExists = 0;
 
524
    u8 userPriority;
 
525
    u32 hdrsize, metasize;
543
526
    ATH_LLC_SNAP_HDR    *llcHdr;
544
527
 
545
528
    WMI_CREATE_PSTREAM_CMD  cmd;
564
547
    {
565
548
        if (processDot11Hdr)
566
549
        {
567
 
             hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(A_UINT32));
 
550
             hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(u32));
568
551
             llcHdr = (ATH_LLC_SNAP_HDR *)(datap + sizeof(WMI_DATA_HDR) + metasize +
569
552
                          hdrsize);
570
553
 
580
563
        {
581
564
            /* Extract the endpoint info from the TOS field in the IP header */
582
565
 
583
 
            userPriority = wmi_determine_userPriority (((A_UINT8 *)llcHdr) + sizeof(ATH_LLC_SNAP_HDR),layer2Priority);
 
566
            userPriority = wmi_determine_userPriority (((u8 *)llcHdr) + sizeof(ATH_LLC_SNAP_HDR),layer2Priority);
584
567
        }
585
568
        else
586
569
        {
621
604
    return trafficClass;
622
605
}
623
606
 
624
 
A_STATUS
 
607
int
625
608
wmi_dot11_hdr_add (struct wmi_t *wmip, void *osbuf, NETWORK_TYPE mode)
626
609
{
627
 
    A_UINT8          *datap;
628
 
    A_UINT16         typeorlen;
 
610
    u8 *datap;
 
611
    u16 typeorlen;
629
612
    ATH_MAC_HDR      macHdr;
630
613
    ATH_LLC_SNAP_HDR *llcHdr;
631
614
    struct           ieee80211_frame *wh;
632
 
    A_UINT32         hdrsize;
 
615
    u32 hdrsize;
633
616
 
634
617
    A_ASSERT(osbuf != NULL);
635
618
 
641
624
 
642
625
    datap = A_NETBUF_DATA(osbuf);
643
626
 
644
 
    typeorlen = *(A_UINT16 *)(datap + ATH_MAC_LEN + ATH_MAC_LEN);
 
627
    typeorlen = *(u16 *)(datap + ATH_MAC_LEN + ATH_MAC_LEN);
645
628
 
646
629
    if (!IS_ETHERTYPE(A_BE2CPU16(typeorlen))) {
647
630
/*
654
637
    /*
655
638
     * Save mac fields and length to be inserted later
656
639
     */
657
 
    A_MEMCPY(macHdr.dstMac, datap, ATH_MAC_LEN);
658
 
    A_MEMCPY(macHdr.srcMac, datap + ATH_MAC_LEN, ATH_MAC_LEN);
 
640
    memcpy(macHdr.dstMac, datap, ATH_MAC_LEN);
 
641
    memcpy(macHdr.srcMac, datap + ATH_MAC_LEN, ATH_MAC_LEN);
659
642
    macHdr.typeOrLen = A_CPU2BE16(A_NETBUF_LEN(osbuf) - sizeof(ATH_MAC_HDR) +
660
643
                                  sizeof(ATH_LLC_SNAP_HDR));
661
644
 
664
647
    /*
665
648
     * Make room for LLC+SNAP headers
666
649
     */
667
 
    if (A_NETBUF_PUSH(osbuf, sizeof(ATH_LLC_SNAP_HDR)) != A_OK) {
 
650
    if (A_NETBUF_PUSH(osbuf, sizeof(ATH_LLC_SNAP_HDR)) != 0) {
668
651
        return A_NO_MEMORY;
669
652
    }
670
653
    datap = A_NETBUF_DATA(osbuf);
682
665
    /* Make room for 802.11 hdr */
683
666
    if (wmip->wmi_is_wmm_enabled)
684
667
    {
685
 
        hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(A_UINT32));
686
 
        if (A_NETBUF_PUSH(osbuf, hdrsize) != A_OK)
 
668
        hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(u32));
 
669
        if (A_NETBUF_PUSH(osbuf, hdrsize) != 0)
687
670
        {
688
671
            return A_NO_MEMORY;
689
672
        }
692
675
    }
693
676
    else
694
677
    {
695
 
        hdrsize = A_ROUND_UP(sizeof(struct ieee80211_frame),sizeof(A_UINT32));
696
 
        if (A_NETBUF_PUSH(osbuf, hdrsize) != A_OK)
 
678
        hdrsize = A_ROUND_UP(sizeof(struct ieee80211_frame),sizeof(u32));
 
679
        if (A_NETBUF_PUSH(osbuf, hdrsize) != 0)
697
680
        {
698
681
            return A_NO_MEMORY;
699
682
        }
710
693
        IEEE80211_ADDR_COPY(wh->i_addr1, macHdr.dstMac);
711
694
    }
712
695
 
713
 
    return (A_OK);
 
696
    return (0);
714
697
}
715
698
 
716
 
A_STATUS
 
699
int
717
700
wmi_dot11_hdr_remove(struct wmi_t *wmip, void *osbuf)
718
701
{
719
 
    A_UINT8          *datap;
 
702
    u8 *datap;
720
703
    struct           ieee80211_frame *pwh,wh;
721
 
    A_UINT8          type,subtype;
 
704
    u8 type,subtype;
722
705
    ATH_LLC_SNAP_HDR *llcHdr;
723
706
    ATH_MAC_HDR      macHdr;
724
 
    A_UINT32         hdrsize;
 
707
    u32 hdrsize;
725
708
 
726
709
    A_ASSERT(osbuf != NULL);
727
710
    datap = A_NETBUF_DATA(osbuf);
730
713
    type = pwh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
731
714
    subtype = pwh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
732
715
 
733
 
    A_MEMCPY((A_UINT8 *)&wh, datap, sizeof(struct ieee80211_frame));
 
716
    memcpy((u8 *)&wh, datap, sizeof(struct ieee80211_frame));
734
717
 
735
718
    /* strip off the 802.11 hdr*/
736
719
    if (subtype == IEEE80211_FC0_SUBTYPE_QOS) {
737
 
        hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(A_UINT32));
 
720
        hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(u32));
738
721
        A_NETBUF_PULL(osbuf, hdrsize);
739
722
    } else if (subtype == IEEE80211_FC0_SUBTYPE_DATA) {
740
723
        A_NETBUF_PULL(osbuf, sizeof(struct ieee80211_frame));
772
755
    A_NETBUF_PUSH(osbuf, sizeof(ATH_MAC_HDR));
773
756
    datap = A_NETBUF_DATA(osbuf);
774
757
 
775
 
    A_MEMCPY (datap, &macHdr, sizeof(ATH_MAC_HDR));
 
758
    memcpy (datap, &macHdr, sizeof(ATH_MAC_HDR));
776
759
 
777
 
    return A_OK;
 
760
    return 0;
778
761
}
779
762
 
780
763
/*
781
764
 *  performs 802.3 to DIX encapsulation for received packets.
782
765
 *  Assumes the entire 802.3 header is contigous.
783
766
 */
784
 
A_STATUS
 
767
int
785
768
wmi_dot3_2_dix(void *osbuf)
786
769
{
787
 
    A_UINT8          *datap;
 
770
    u8 *datap;
788
771
    ATH_MAC_HDR      macHdr;
789
772
    ATH_LLC_SNAP_HDR *llcHdr;
790
773
 
791
774
    A_ASSERT(osbuf != NULL);
792
775
    datap = A_NETBUF_DATA(osbuf);
793
776
 
794
 
    A_MEMCPY(&macHdr, datap, sizeof(ATH_MAC_HDR));
 
777
    memcpy(&macHdr, datap, sizeof(ATH_MAC_HDR));
795
778
    llcHdr = (ATH_LLC_SNAP_HDR *)(datap + sizeof(ATH_MAC_HDR));
796
779
    macHdr.typeOrLen = llcHdr->etherType;
797
780
 
798
 
    if (A_NETBUF_PULL(osbuf, sizeof(ATH_LLC_SNAP_HDR)) != A_OK) {
 
781
    if (A_NETBUF_PULL(osbuf, sizeof(ATH_LLC_SNAP_HDR)) != 0) {
799
782
        return A_NO_MEMORY;
800
783
    }
801
784
 
802
785
    datap = A_NETBUF_DATA(osbuf);
803
786
 
804
 
    A_MEMCPY(datap, &macHdr, sizeof (ATH_MAC_HDR));
 
787
    memcpy(datap, &macHdr, sizeof (ATH_MAC_HDR));
805
788
 
806
 
    return (A_OK);
 
789
    return (0);
807
790
}
808
791
 
809
792
/*
810
793
 * Removes a WMI data header
811
794
 */
812
 
A_STATUS
 
795
int
813
796
wmi_data_hdr_remove(struct wmi_t *wmip, void *osbuf)
814
797
{
815
798
    A_ASSERT(osbuf != NULL);
826
809
/*
827
810
 * WMI Extended Event received from Target.
828
811
 */
829
 
A_STATUS
 
812
int
830
813
wmi_control_rx_xtnd(struct wmi_t *wmip, void *osbuf)
831
814
{
832
815
    WMIX_CMD_HDR *cmd;
833
 
    A_UINT16 id;
834
 
    A_UINT8 *datap;
835
 
    A_UINT32 len;
836
 
    A_STATUS status = A_OK;
 
816
    u16 id;
 
817
    u8 *datap;
 
818
    u32 len;
 
819
    int status = 0;
837
820
 
838
821
    if (A_NETBUF_LEN(osbuf) < sizeof(WMIX_CMD_HDR)) {
839
822
        A_DPRINTF(DBG_WMI, (DBGFMT "bad packet 1\n", DBGARG));
844
827
    cmd = (WMIX_CMD_HDR *)A_NETBUF_DATA(osbuf);
845
828
    id = cmd->commandId;
846
829
 
847
 
    if (A_NETBUF_PULL(osbuf, sizeof(WMIX_CMD_HDR)) != A_OK) {
 
830
    if (A_NETBUF_PULL(osbuf, sizeof(WMIX_CMD_HDR)) != 0) {
848
831
        A_DPRINTF(DBG_WMI, (DBGFMT "bad packet 2\n", DBGARG));
849
832
        wmip->wmi_stats.cmd_len_err++;
850
833
        return A_ERROR;
865
848
        status = wmi_dset_data_req_rx(wmip, datap, len);
866
849
        break;
867
850
#endif /* CONFIG_HOST_DSET_SUPPORT */
868
 
#ifdef CONFIG_HOST_GPIO_SUPPORT
869
 
    case (WMIX_GPIO_INTR_EVENTID):
870
 
        wmi_gpio_intr_rx(wmip, datap, len);
871
 
        break;
872
 
    case (WMIX_GPIO_DATA_EVENTID):
873
 
        wmi_gpio_data_rx(wmip, datap, len);
874
 
        break;
875
 
    case (WMIX_GPIO_ACK_EVENTID):
876
 
        wmi_gpio_ack_rx(wmip, datap, len);
877
 
        break;
878
 
#endif /* CONFIG_HOST_GPIO_SUPPORT */
879
851
    case (WMIX_HB_CHALLENGE_RESP_EVENTID):
880
852
        wmi_hbChallengeResp_rx(wmip, datap, len);
881
853
        break;
901
873
/*
902
874
 * Control Path
903
875
 */
904
 
A_UINT32 cmdRecvNum;
 
876
u32 cmdRecvNum;
905
877
 
906
 
A_STATUS
 
878
int
907
879
wmi_control_rx(struct wmi_t *wmip, void *osbuf)
908
880
{
909
881
    WMI_CMD_HDR *cmd;
910
 
    A_UINT16 id;
911
 
    A_UINT8 *datap;
912
 
    A_UINT32 len, i, loggingReq;
913
 
    A_STATUS status = A_OK;
 
882
    u16 id;
 
883
    u8 *datap;
 
884
    u32 len, i, loggingReq;
 
885
    int status = 0;
914
886
 
915
887
    A_ASSERT(osbuf != NULL);
916
888
    if (A_NETBUF_LEN(osbuf) < sizeof(WMI_CMD_HDR)) {
923
895
    cmd = (WMI_CMD_HDR *)A_NETBUF_DATA(osbuf);
924
896
    id = cmd->commandId;
925
897
 
926
 
    if (A_NETBUF_PULL(osbuf, sizeof(WMI_CMD_HDR)) != A_OK) {
 
898
    if (A_NETBUF_PULL(osbuf, sizeof(WMI_CMD_HDR)) != 0) {
927
899
        A_NETBUF_FREE(osbuf);
928
900
        A_DPRINTF(DBG_WMI, (DBGFMT "bad packet 2\n", DBGARG));
929
901
        wmip->wmi_stats.cmd_len_err++;
967
939
    case (WMI_READY_EVENTID):
968
940
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_READY_EVENTID\n", DBGARG));
969
941
        status = wmi_ready_event_rx(wmip, datap, len);
970
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
971
942
        A_WMI_DBGLOG_INIT_DONE(wmip->wmi_devt);
972
943
        break;
973
944
    case (WMI_CONNECT_EVENTID):
974
945
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_CONNECT_EVENTID\n", DBGARG));
975
946
        status = wmi_connect_event_rx(wmip, datap, len);
976
 
        A_WMI_SEND_GENERIC_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
977
947
        break;
978
948
    case (WMI_DISCONNECT_EVENTID):
979
949
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_DISCONNECT_EVENTID\n", DBGARG));
980
950
        status = wmi_disconnect_event_rx(wmip, datap, len);
981
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
982
951
        break;
983
952
    case (WMI_PEER_NODE_EVENTID):
984
953
        A_DPRINTF (DBG_WMI, (DBGFMT "WMI_PEER_NODE_EVENTID\n", DBGARG));
985
954
        status = wmi_peer_node_event_rx(wmip, datap, len);
986
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
987
955
        break;
988
956
    case (WMI_TKIP_MICERR_EVENTID):
989
957
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_TKIP_MICERR_EVENTID\n", DBGARG));
999
967
            */
1000
968
            WMI_BSS_INFO_HDR2 bih2;
1001
969
            WMI_BSS_INFO_HDR *bih;
1002
 
            A_MEMCPY(&bih2, datap, sizeof(WMI_BSS_INFO_HDR2));
 
970
            memcpy(&bih2, datap, sizeof(WMI_BSS_INFO_HDR2));
1003
971
 
1004
972
            A_NETBUF_PUSH(osbuf, 4);
1005
973
            datap = A_NETBUF_DATA(osbuf);
1011
979
            bih->snr = bih2.snr;
1012
980
            bih->rssi = bih2.snr - 95;
1013
981
            bih->ieMask = bih2.ieMask;
1014
 
            A_MEMCPY(bih->bssid, bih2.bssid, ATH_MAC_LEN);
 
982
            memcpy(bih->bssid, bih2.bssid, ATH_MAC_LEN);
1015
983
 
1016
984
            status = wmi_bssInfo_event_rx(wmip, datap, len);
1017
 
            A_WMI_SEND_GENERIC_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
1018
985
        }
1019
986
        break;
1020
987
    case (WMI_REGDOMAIN_EVENTID):
1024
991
    case (WMI_PSTREAM_TIMEOUT_EVENTID):
1025
992
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_PSTREAM_TIMEOUT_EVENTID\n", DBGARG));
1026
993
        status = wmi_pstream_timeout_event_rx(wmip, datap, len);
1027
 
            /* pstreams are fatpipe abstractions that get implicitly created.
1028
 
             * User apps only deal with thinstreams. creation of a thinstream
1029
 
             * by the user or data traffic flow in an AC triggers implicit
1030
 
             * pstream creation. Do we need to send this event to App..?
1031
 
             * no harm in sending it.
1032
 
             */
1033
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
1034
994
        break;
1035
995
    case (WMI_NEIGHBOR_REPORT_EVENTID):
1036
996
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_NEIGHBOR_REPORT_EVENTID\n", DBGARG));
1039
999
    case (WMI_SCAN_COMPLETE_EVENTID):
1040
1000
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_SCAN_COMPLETE_EVENTID\n", DBGARG));
1041
1001
        status = wmi_scanComplete_rx(wmip, datap, len);
1042
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
1043
1002
        break;
1044
1003
    case (WMI_CMDERROR_EVENTID):
1045
1004
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_CMDERROR_EVENTID\n", DBGARG));
1056
1015
    case (WMI_ERROR_REPORT_EVENTID):
1057
1016
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_ERROR_REPORT_EVENTID\n", DBGARG));
1058
1017
        status = wmi_reportErrorEvent_rx(wmip, datap, len);
1059
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
1060
1018
        break;
1061
1019
    case (WMI_OPT_RX_FRAME_EVENTID):
1062
1020
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_OPT_RX_FRAME_EVENTID\n", DBGARG));
1095
1053
    case (WMI_TX_RETRY_ERR_EVENTID):
1096
1054
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_TX_RETRY_ERR_EVENTID\n", DBGARG));
1097
1055
        status = wmi_txRetryErrEvent_rx(wmip, datap, len);
1098
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
1099
1056
        break;
1100
1057
    case (WMI_SNR_THRESHOLD_EVENTID):
1101
1058
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_SNR_THRESHOLD_EVENTID\n", DBGARG));
1104
1061
    case (WMI_LQ_THRESHOLD_EVENTID):
1105
1062
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_LQ_THRESHOLD_EVENTID\n", DBGARG));
1106
1063
        status = wmi_lqThresholdEvent_rx(wmip, datap, len);
1107
 
        A_WMI_SEND_EVENT_TO_APP(wmip->wmi_devt, id, datap, len);
1108
1064
        break;
1109
1065
    case (WMI_APLIST_EVENTID):
1110
1066
        AR_DEBUG_PRINTF(ATH_DEBUG_WMI, ("Received APLIST Event\n"));
1133
1089
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_SET_PARAMS_REPLY Event\n", DBGARG));
1134
1090
        status = wmi_set_params_event_rx(wmip, datap, len);
1135
1091
        break;
1136
 
    case (WMI_ACM_REJECT_EVENTID):
1137
 
        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_SET_PARAMS_REPLY Event\n", DBGARG));
1138
 
        status = wmi_acm_reject_event_rx(wmip, datap, len);
1139
 
        break;          
1140
 
#ifdef ATH_AR6K_11N_SUPPORT
1141
1092
    case (WMI_ADDBA_REQ_EVENTID):
1142
1093
        status = wmi_addba_req_event_rx(wmip, datap, len);
1143
1094
        break;
1155
1106
            A_DPRINTF(DBG_WMI, (DBGFMT "WMI_BTCOEX_STATS_EVENTID", DBGARG));
1156
1107
        status = wmi_btcoex_stats_event_rx(wmip, datap, len);
1157
1108
            break;
1158
 
#endif
1159
1109
    case (WMI_TX_COMPLETE_EVENTID):
1160
1110
        {
1161
1111
            int index;
1192
1142
}
1193
1143
 
1194
1144
/* Send a "simple" wmi command -- one with no arguments */
1195
 
static A_STATUS
 
1145
static int
1196
1146
wmi_simple_cmd(struct wmi_t *wmip, WMI_COMMAND_ID cmdid)
1197
1147
{
1198
1148
    void *osbuf;
1208
1158
/* Send a "simple" extended wmi command -- one with no arguments.
1209
1159
   Enabling this command only if GPIO or profiling support is enabled.
1210
1160
   This is to suppress warnings on some platforms */
1211
 
#if defined(CONFIG_HOST_GPIO_SUPPORT) || defined(CONFIG_TARGET_PROFILE_SUPPORT)
1212
 
static A_STATUS
 
1161
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
 
1162
static int
1213
1163
wmi_simple_cmd_xtnd(struct wmi_t *wmip, WMIX_COMMAND_ID cmdid)
1214
1164
{
1215
1165
    void *osbuf;
1223
1173
}
1224
1174
#endif
1225
1175
 
1226
 
static A_STATUS
1227
 
wmi_ready_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1176
static int
 
1177
wmi_ready_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1228
1178
{
1229
1179
    WMI_READY_EVENT *ev = (WMI_READY_EVENT *)datap;
1230
1180
 
1232
1182
        return A_EINVAL;
1233
1183
    }
1234
1184
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
1235
 
    wmip->wmi_ready = TRUE;
 
1185
    wmip->wmi_ready = true;
1236
1186
    A_WMI_READY_EVENT(wmip->wmi_devt, ev->macaddr, ev->phyCapability,
1237
1187
                      ev->sw_version, ev->abi_version);
1238
1188
 
1239
 
    return A_OK;
 
1189
    return 0;
1240
1190
}
1241
1191
 
1242
1192
#define LE_READ_4(p)                            \
1243
 
    ((A_UINT32)                            \
1244
 
     ((((A_UINT8 *)(p))[0]      ) | (((A_UINT8 *)(p))[1] <<  8) | \
1245
 
      (((A_UINT8 *)(p))[2] << 16) | (((A_UINT8 *)(p))[3] << 24)))
 
1193
    ((u32)                            \
 
1194
     ((((u8 *)(p))[0]      ) | (((u8 *)(p))[1] <<  8) | \
 
1195
      (((u8 *)(p))[2] << 16) | (((u8 *)(p))[3] << 24)))
1246
1196
 
1247
1197
static int __inline
1248
 
iswmmoui(const A_UINT8 *frm)
 
1198
iswmmoui(const u8 *frm)
1249
1199
{
1250
1200
    return frm[1] > 3 && LE_READ_4(frm+2) == ((WMM_OUI_TYPE<<24)|WMM_OUI);
1251
1201
}
1252
1202
 
1253
1203
static int __inline
1254
 
iswmmparam(const A_UINT8 *frm)
 
1204
iswmmparam(const u8 *frm)
1255
1205
{
1256
1206
    return frm[1] > 5 && frm[6] == WMM_PARAM_OUI_SUBTYPE;
1257
1207
}
1258
1208
 
1259
1209
 
1260
 
static A_STATUS
1261
 
wmi_connect_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1210
static int
 
1211
wmi_connect_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1262
1212
{
1263
1213
    WMI_CONNECT_EVENT *ev;
1264
 
    A_UINT8 *pie,*peie;
 
1214
    u8 *pie,*peie;
1265
1215
 
1266
1216
    if (len < sizeof(WMI_CONNECT_EVENT))
1267
1217
    {
1275
1225
        ev->bssid[0], ev->bssid[1], ev->bssid[2],
1276
1226
        ev->bssid[3], ev->bssid[4], ev->bssid[5]));
1277
1227
 
1278
 
    A_MEMCPY(wmip->wmi_bssid, ev->bssid, ATH_MAC_LEN);
 
1228
    memcpy(wmip->wmi_bssid, ev->bssid, ATH_MAC_LEN);
1279
1229
 
1280
1230
    /* initialize pointer to start of assoc rsp IEs */
1281
1231
    pie = ev->assocInfo + ev->beaconIeLen + ev->assocReqLen +
1282
 
                            sizeof(A_UINT16)  +  /* capinfo*/
1283
 
                            sizeof(A_UINT16)  +  /* status Code */
1284
 
                            sizeof(A_UINT16)  ;  /* associd */
 
1232
                            sizeof(u16)  +  /* capinfo*/
 
1233
                            sizeof(u16)  +  /* status Code */
 
1234
                            sizeof(u16)  ;  /* associd */
1285
1235
 
1286
1236
    /* initialize pointer to end of assoc rsp IEs */
1287
1237
    peie = ev->assocInfo + ev->beaconIeLen + ev->assocReqLen + ev->assocRespLen;
1295
1245
                {
1296
1246
                    if(iswmmparam (pie))
1297
1247
                    {
1298
 
                        wmip->wmi_is_wmm_enabled = TRUE;
 
1248
                        wmip->wmi_is_wmm_enabled = true;
1299
1249
                    }
1300
1250
                }
1301
1251
            break;
1314
1264
                         ev->assocReqLen, ev->assocRespLen,
1315
1265
                         ev->assocInfo);
1316
1266
 
1317
 
    return A_OK;
 
1267
    return 0;
1318
1268
}
1319
1269
 
1320
 
static A_STATUS
1321
 
wmi_regDomain_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1270
static int
 
1271
wmi_regDomain_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1322
1272
{
1323
1273
    WMI_REG_DOMAIN_EVENT *ev;
1324
1274
 
1329
1279
 
1330
1280
    A_WMI_REGDOMAIN_EVENT(wmip->wmi_devt, ev->regDomain);
1331
1281
 
1332
 
    return A_OK;
 
1282
    return 0;
1333
1283
}
1334
1284
 
1335
 
static A_STATUS
1336
 
wmi_neighborReport_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1285
static int
 
1286
wmi_neighborReport_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1337
1287
{
1338
1288
    WMI_NEIGHBOR_REPORT_EVENT *ev;
1339
1289
    int numAps;
1350
1300
 
1351
1301
    A_WMI_NEIGHBORREPORT_EVENT(wmip->wmi_devt, numAps, ev->neighbor);
1352
1302
 
1353
 
    return A_OK;
 
1303
    return 0;
1354
1304
}
1355
1305
 
1356
 
static A_STATUS
1357
 
wmi_disconnect_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1306
static int
 
1307
wmi_disconnect_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1358
1308
{
1359
1309
    WMI_DISCONNECT_EVENT *ev;
1360
1310
    wmip->wmi_traffic_class = 100;
1368
1318
 
1369
1319
    A_MEMZERO(wmip->wmi_bssid, sizeof(wmip->wmi_bssid));
1370
1320
 
1371
 
    wmip->wmi_is_wmm_enabled = FALSE;
 
1321
    wmip->wmi_is_wmm_enabled = false;
1372
1322
    wmip->wmi_pair_crypto_type = NONE_CRYPT;
1373
1323
    wmip->wmi_grp_crypto_type = NONE_CRYPT;
1374
1324
 
1375
1325
    A_WMI_DISCONNECT_EVENT(wmip->wmi_devt, ev->disconnectReason, ev->bssid,
1376
1326
                            ev->assocRespLen, ev->assocInfo, ev->protocolReasonStatus);
1377
1327
 
1378
 
    return A_OK;
 
1328
    return 0;
1379
1329
}
1380
1330
 
1381
 
static A_STATUS
1382
 
wmi_peer_node_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1331
static int
 
1332
wmi_peer_node_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1383
1333
{
1384
1334
    WMI_PEER_NODE_EVENT *ev;
1385
1335
 
1395
1345
 
1396
1346
    A_WMI_PEER_EVENT (wmip->wmi_devt, ev->eventCode, ev->peerMacAddr);
1397
1347
 
1398
 
    return A_OK;
 
1348
    return 0;
1399
1349
}
1400
1350
 
1401
 
static A_STATUS
1402
 
wmi_tkip_micerr_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1351
static int
 
1352
wmi_tkip_micerr_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1403
1353
{
1404
1354
    WMI_TKIP_MICERR_EVENT *ev;
1405
1355
 
1411
1361
    ev = (WMI_TKIP_MICERR_EVENT *)datap;
1412
1362
    A_WMI_TKIP_MICERR_EVENT(wmip->wmi_devt, ev->keyid, ev->ismcast);
1413
1363
 
1414
 
    return A_OK;
 
1364
    return 0;
1415
1365
}
1416
1366
 
1417
 
static A_STATUS
1418
 
wmi_bssInfo_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1367
static int
 
1368
wmi_bssInfo_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1419
1369
{
1420
1370
    bss_t *bss = NULL;
1421
1371
    WMI_BSS_INFO_HDR *bih;
1422
 
    A_UINT8 *buf;
1423
 
    A_UINT32 nodeCachingAllowed = 1;
1424
 
    A_UCHAR cached_ssid_len = 0;
1425
 
    A_UCHAR cached_ssid_buf[IEEE80211_NWID_LEN] = {0};
1426
 
    A_UINT8 beacon_ssid_len = 0;
 
1372
    u8 *buf;
 
1373
    u32 nodeCachingAllowed = 1;
 
1374
    u8 cached_ssid_len = 0;
 
1375
    u8 cached_ssid_buf[IEEE80211_NWID_LEN] = {0};
 
1376
    u8 beacon_ssid_len = 0;
1427
1377
 
1428
1378
    if (len <= sizeof(WMI_BSS_INFO_HDR)) {
1429
1379
        return A_EINVAL;
1434
1384
 
1435
1385
    if (bih->rssi > 0) {
1436
1386
        if (NULL == bss)
1437
 
            return A_OK;  //no node found in the table, just drop the node with incorrect RSSI
 
1387
            return 0;  //no node found in the table, just drop the node with incorrect RSSI
1438
1388
        else
1439
1389
            bih->rssi = bss->ni_rssi; //Adjust RSSI in datap in case it is used in A_WMI_BSSINFO_EVENT_RX
1440
1390
    }
1443
1393
    /* What is driver config for wlan node caching? */
1444
1394
    if(ar6000_get_driver_cfg(wmip->wmi_devt,
1445
1395
                    AR6000_DRIVER_CFG_GET_WLANNODECACHING,
1446
 
                    &nodeCachingAllowed) != A_OK) {
 
1396
                    &nodeCachingAllowed) != 0) {
1447
1397
        wmi_node_return(wmip, bss);
1448
1398
        return A_EINVAL;
1449
1399
    }
1450
1400
 
1451
1401
    if(!nodeCachingAllowed) {
1452
1402
        wmi_node_return(wmip, bss);
1453
 
        return A_OK;
 
1403
        return 0;
1454
1404
    }
1455
1405
 
1456
1406
    buf = datap + sizeof(WMI_BSS_INFO_HDR);
1462
1412
 
1463
1413
    if(wps_enable && (bih->frameType == PROBERESP_FTYPE) ) {
1464
1414
        wmi_node_return(wmip, bss);
1465
 
        return A_OK;
 
1415
        return 0;
1466
1416
    }
1467
1417
 
1468
1418
    if (bss != NULL) {
1475
1425
        /* In case of hidden AP, beacon will not have ssid,
1476
1426
         * but a directed probe response will have it,
1477
1427
         * so cache the probe-resp-ssid if already present. */
1478
 
        if ((TRUE == is_probe_ssid) && (BEACON_FTYPE == bih->frameType))
 
1428
        if ((true == is_probe_ssid) && (BEACON_FTYPE == bih->frameType))
1479
1429
        {
1480
 
            A_UCHAR *ie_ssid;
 
1430
            u8 *ie_ssid;
1481
1431
 
1482
1432
            ie_ssid = bss->ni_cie.ie_ssid;
1483
1433
            if(ie_ssid && (ie_ssid[1] <= IEEE80211_NWID_LEN) && (ie_ssid[2] != 0))
1510
1460
    beacon_ssid_len = buf[SSID_IE_LEN_INDEX];
1511
1461
 
1512
1462
    /* If ssid is cached for this hidden AP, then change buffer len accordingly. */
1513
 
    if ((TRUE == is_probe_ssid) && (BEACON_FTYPE == bih->frameType) &&
 
1463
    if ((true == is_probe_ssid) && (BEACON_FTYPE == bih->frameType) &&
1514
1464
        (0 != cached_ssid_len) &&
1515
1465
        (0 == beacon_ssid_len || (cached_ssid_len > beacon_ssid_len && 0 == buf[SSID_IE_LEN_INDEX + 1])))
1516
1466
    {
1529
1479
    /* In case of hidden AP, beacon will not have ssid,
1530
1480
     * but a directed probe response will have it,
1531
1481
     * so place the cached-ssid(probe-resp) in the bssinfo. */
1532
 
    if ((TRUE == is_probe_ssid) && (BEACON_FTYPE == bih->frameType) &&
 
1482
    if ((true == is_probe_ssid) && (BEACON_FTYPE == bih->frameType) &&
1533
1483
         (0 != cached_ssid_len) &&
1534
1484
         (0 == beacon_ssid_len || (beacon_ssid_len && 0 == buf[SSID_IE_LEN_INDEX + 1])))
1535
1485
    {
1536
 
        A_UINT8 *ni_buf = bss->ni_buf;
 
1486
        u8 *ni_buf = bss->ni_buf;
1537
1487
        int buf_len = len;
1538
1488
 
1539
1489
        /* copy the first 14 bytes such as
1540
1490
         * time-stamp(8), beacon-interval(2), cap-info(2), ssid-id(1), ssid-len(1). */
1541
 
        A_MEMCPY(ni_buf, buf, SSID_IE_LEN_INDEX + 1);
 
1491
        memcpy(ni_buf, buf, SSID_IE_LEN_INDEX + 1);
1542
1492
 
1543
1493
        ni_buf[SSID_IE_LEN_INDEX] = cached_ssid_len;
1544
1494
        ni_buf += (SSID_IE_LEN_INDEX + 1);
1547
1497
        buf_len -= (SSID_IE_LEN_INDEX + 1);
1548
1498
 
1549
1499
        /* copy the cached ssid */
1550
 
        A_MEMCPY(ni_buf, cached_ssid_buf, cached_ssid_len);
 
1500
        memcpy(ni_buf, cached_ssid_buf, cached_ssid_len);
1551
1501
        ni_buf += cached_ssid_len;
1552
1502
 
1553
1503
        buf += beacon_ssid_len;
1557
1507
            buf_len -= (cached_ssid_len - beacon_ssid_len);
1558
1508
 
1559
1509
        /* now copy the rest of bytes */
1560
 
        A_MEMCPY(ni_buf, buf, buf_len);
 
1510
        memcpy(ni_buf, buf, buf_len);
1561
1511
    }
1562
1512
    else
1563
 
        A_MEMCPY(bss->ni_buf, buf, len);
 
1513
        memcpy(bss->ni_buf, buf, len);
1564
1514
 
1565
1515
    bss->ni_framelen = len;
1566
 
    if (wlan_parse_beacon(bss->ni_buf, len, &bss->ni_cie) != A_OK) {
 
1516
    if (wlan_parse_beacon(bss->ni_buf, len, &bss->ni_cie) != 0) {
1567
1517
        wlan_node_free(bss);
1568
1518
        return A_EINVAL;
1569
1519
    }
1575
1525
    bss->ni_cie.ie_chan = bih->channel;
1576
1526
    wlan_setup_node(&wmip->wmi_scan_table, bss, bih->bssid);
1577
1527
 
1578
 
    return A_OK;
 
1528
    return 0;
1579
1529
}
1580
1530
 
1581
 
static A_STATUS
1582
 
wmi_opt_frame_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1531
static int
 
1532
wmi_opt_frame_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1583
1533
{
1584
1534
    bss_t *bss;
1585
1535
    WMI_OPT_RX_INFO_HDR *bih;
1586
 
    A_UINT8 *buf;
 
1536
    u8 *buf;
1587
1537
 
1588
1538
    if (len <= sizeof(WMI_OPT_RX_INFO_HDR)) {
1589
1539
        return A_EINVAL;
1614
1564
    bss->ni_snr        = bih->snr;
1615
1565
    bss->ni_cie.ie_chan = bih->channel;
1616
1566
    A_ASSERT(bss->ni_buf != NULL);
1617
 
    A_MEMCPY(bss->ni_buf, buf, len);
 
1567
    memcpy(bss->ni_buf, buf, len);
1618
1568
    wlan_setup_node(&wmip->wmi_scan_table, bss, bih->bssid);
1619
1569
 
1620
 
    return A_OK;
 
1570
    return 0;
1621
1571
}
1622
1572
 
1623
1573
    /* This event indicates inactivity timeout of a fatpipe(pstream)
1624
1574
     * at the target
1625
1575
     */
1626
 
static A_STATUS
1627
 
wmi_pstream_timeout_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1576
static int
 
1577
wmi_pstream_timeout_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1628
1578
{
1629
1579
    WMI_PSTREAM_TIMEOUT_EVENT *ev;
1630
1580
 
1650
1600
        /*Indicate inactivity to driver layer for this fatpipe (pstream)*/
1651
1601
    A_WMI_STREAM_TX_INACTIVE(wmip->wmi_devt, ev->trafficClass);
1652
1602
 
1653
 
    return A_OK;
 
1603
    return 0;
1654
1604
}
1655
1605
 
1656
 
static A_STATUS
1657
 
wmi_bitrate_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1606
static int
 
1607
wmi_bitrate_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
1658
1608
{
1659
1609
    WMI_BIT_RATE_REPLY *reply;
1660
 
    A_INT32 rate;
1661
 
    A_UINT32 sgi,index;
 
1610
    s32 rate;
 
1611
    u32 sgi,index;
1662
1612
    /* 54149:
1663
1613
     * WMI_BIT_RATE_CMD structure is changed to WMI_BIT_RATE_REPLY.
1664
1614
     * since there is difference in the length and to avoid returning
1671
1621
    A_DPRINTF(DBG_WMI,
1672
1622
        (DBGFMT "Enter - rateindex %d\n", DBGARG, reply->rateIndex));
1673
1623
 
1674
 
    if (reply->rateIndex == (A_INT8) RATE_AUTO) {
 
1624
    if (reply->rateIndex == (s8) RATE_AUTO) {
1675
1625
        rate = RATE_AUTO;
1676
1626
    } else {
1677
1627
        // the SGI state is stored as the MSb of the rateIndex
1681
1631
    }
1682
1632
 
1683
1633
    A_WMI_BITRATE_RX(wmip->wmi_devt, rate);
1684
 
    return A_OK;
 
1634
    return 0;
1685
1635
}
1686
1636
 
1687
 
static A_STATUS
1688
 
wmi_ratemask_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1637
static int
 
1638
wmi_ratemask_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
1689
1639
{
1690
1640
    WMI_FIX_RATES_REPLY *reply;
1691
1641
 
1698
1648
 
1699
1649
    A_WMI_RATEMASK_RX(wmip->wmi_devt, reply->fixRateMask);
1700
1650
 
1701
 
    return A_OK;
 
1651
    return 0;
1702
1652
}
1703
1653
 
1704
 
static A_STATUS
1705
 
wmi_channelList_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1654
static int
 
1655
wmi_channelList_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
1706
1656
{
1707
1657
    WMI_CHANNEL_LIST_REPLY *reply;
1708
1658
 
1715
1665
    A_WMI_CHANNELLIST_RX(wmip->wmi_devt, reply->numChannels,
1716
1666
                          reply->channelList);
1717
1667
 
1718
 
    return A_OK;
 
1668
    return 0;
1719
1669
}
1720
1670
 
1721
 
static A_STATUS
1722
 
wmi_txPwr_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1671
static int
 
1672
wmi_txPwr_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
1723
1673
{
1724
1674
    WMI_TX_PWR_REPLY *reply;
1725
1675
 
1731
1681
 
1732
1682
    A_WMI_TXPWR_RX(wmip->wmi_devt, reply->dbM);
1733
1683
 
1734
 
    return A_OK;
 
1684
    return 0;
1735
1685
}
1736
 
static A_STATUS
1737
 
wmi_keepalive_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1686
static int
 
1687
wmi_keepalive_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
1738
1688
{
1739
1689
    WMI_GET_KEEPALIVE_CMD *reply;
1740
1690
 
1746
1696
 
1747
1697
    A_WMI_KEEPALIVE_RX(wmip->wmi_devt, reply->configured);
1748
1698
 
1749
 
    return A_OK;
 
1699
    return 0;
1750
1700
}
1751
1701
 
1752
1702
 
1753
 
static A_STATUS
1754
 
wmi_dset_open_req_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1703
static int
 
1704
wmi_dset_open_req_rx(struct wmi_t *wmip, u8 *datap, int len)
1755
1705
{
1756
1706
    WMIX_DSETOPENREQ_EVENT *dsetopenreq;
1757
1707
 
1767
1717
                        dsetopenreq->targ_reply_fn,
1768
1718
                        dsetopenreq->targ_reply_arg);
1769
1719
 
1770
 
    return A_OK;
 
1720
    return 0;
1771
1721
}
1772
1722
 
1773
1723
#ifdef CONFIG_HOST_DSET_SUPPORT
1774
 
static A_STATUS
1775
 
wmi_dset_close_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1724
static int
 
1725
wmi_dset_close_rx(struct wmi_t *wmip, u8 *datap, int len)
1776
1726
{
1777
1727
    WMIX_DSETCLOSE_EVENT *dsetclose;
1778
1728
 
1784
1734
    dsetclose = (WMIX_DSETCLOSE_EVENT *)datap;
1785
1735
    A_WMI_DSET_CLOSE(wmip->wmi_devt, dsetclose->access_cookie);
1786
1736
 
1787
 
    return A_OK;
 
1737
    return 0;
1788
1738
}
1789
1739
 
1790
 
static A_STATUS
1791
 
wmi_dset_data_req_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1740
static int
 
1741
wmi_dset_data_req_rx(struct wmi_t *wmip, u8 *datap, int len)
1792
1742
{
1793
1743
    WMIX_DSETDATAREQ_EVENT *dsetdatareq;
1794
1744
 
1806
1756
                         dsetdatareq->targ_reply_fn,
1807
1757
                         dsetdatareq->targ_reply_arg);
1808
1758
 
1809
 
    return A_OK;
 
1759
    return 0;
1810
1760
}
1811
1761
#endif /* CONFIG_HOST_DSET_SUPPORT */
1812
1762
 
1813
 
static A_STATUS
1814
 
wmi_scanComplete_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1763
static int
 
1764
wmi_scanComplete_rx(struct wmi_t *wmip, u8 *datap, int len)
1815
1765
{
1816
1766
    WMI_SCAN_COMPLETE_EVENT *ev;
1817
1767
 
1818
1768
    ev = (WMI_SCAN_COMPLETE_EVENT *)datap;
1819
 
    if ((A_STATUS)ev->status == A_OK) {
 
1769
    if ((int)ev->status == 0) {
1820
1770
        wlan_refresh_inactive_nodes(&wmip->wmi_scan_table);
1821
1771
    }
1822
 
    A_WMI_SCANCOMPLETE_EVENT(wmip->wmi_devt, (A_STATUS) ev->status);
1823
 
    is_probe_ssid = FALSE;
 
1772
    A_WMI_SCANCOMPLETE_EVENT(wmip->wmi_devt, (int) ev->status);
 
1773
    is_probe_ssid = false;
1824
1774
 
1825
 
    return A_OK;
 
1775
    return 0;
1826
1776
}
1827
1777
 
1828
1778
/*
1832
1782
 * Behavior of target after wmi error event is undefined.
1833
1783
 * A reset is recommended.
1834
1784
 */
1835
 
static A_STATUS
1836
 
wmi_errorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1785
static int
 
1786
wmi_errorEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
1837
1787
{
1838
1788
    WMI_CMD_ERROR_EVENT *ev;
1839
1789
 
1851
1801
        break;
1852
1802
    }
1853
1803
 
1854
 
    return A_OK;
 
1804
    return 0;
1855
1805
}
1856
1806
 
1857
1807
 
1858
 
static A_STATUS
1859
 
wmi_statsEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1808
static int
 
1809
wmi_statsEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
1860
1810
{
1861
1811
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
1862
1812
 
1863
1813
    A_WMI_TARGETSTATS_EVENT(wmip->wmi_devt, datap, len);
1864
1814
 
1865
 
    return A_OK;
 
1815
    return 0;
1866
1816
}
1867
1817
 
1868
 
static A_STATUS
1869
 
wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1818
static int
 
1819
wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
1870
1820
{
1871
1821
    WMI_RSSI_THRESHOLD_EVENT *reply;
1872
1822
    WMI_RSSI_THRESHOLD_VAL newThreshold;
1873
1823
    WMI_RSSI_THRESHOLD_PARAMS_CMD cmd;
1874
1824
    SQ_THRESHOLD_PARAMS *sq_thresh =
1875
1825
           &wmip->wmi_SqThresholdParams[SIGNAL_QUALITY_METRICS_RSSI];
1876
 
    A_UINT8 upper_rssi_threshold, lower_rssi_threshold;
1877
 
    A_INT16 rssi;
 
1826
    u8 upper_rssi_threshold, lower_rssi_threshold;
 
1827
    s16 rssi;
1878
1828
 
1879
1829
    if (len < sizeof(*reply)) {
1880
1830
        return A_EINVAL;
1959
1909
 
1960
1910
    rssi_event_value = rssi;
1961
1911
 
1962
 
    if (wmi_send_rssi_threshold_params(wmip, &cmd) != A_OK) {
 
1912
    if (wmi_send_rssi_threshold_params(wmip, &cmd) != 0) {
1963
1913
        A_DPRINTF(DBG_WMI, (DBGFMT "Unable to configure the RSSI thresholds\n",
1964
1914
                  DBGARG));
1965
1915
    }
1966
1916
 
1967
1917
    A_WMI_RSSI_THRESHOLD_EVENT(wmip->wmi_devt, newThreshold, reply->rssi);
1968
1918
 
1969
 
    return A_OK;
 
1919
    return 0;
1970
1920
}
1971
1921
 
1972
1922
 
1973
 
static A_STATUS
1974
 
wmi_reportErrorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1923
static int
 
1924
wmi_reportErrorEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
1975
1925
{
1976
1926
    WMI_TARGET_ERROR_REPORT_EVENT *reply;
1977
1927
 
1983
1933
 
1984
1934
    A_WMI_REPORT_ERROR_EVENT(wmip->wmi_devt, (WMI_TARGET_ERROR_VAL) reply->errorVal);
1985
1935
 
1986
 
    return A_OK;
 
1936
    return 0;
1987
1937
}
1988
1938
 
1989
 
static A_STATUS
1990
 
wmi_cac_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
1939
static int
 
1940
wmi_cac_event_rx(struct wmi_t *wmip, u8 *datap, int len)
1991
1941
{
1992
1942
    WMI_CAC_EVENT *reply;
1993
1943
    WMM_TSPEC_IE *tspec_ie;
1994
 
    A_UINT16 activeTsids;
 
1944
    u16 activeTsids;
1995
1945
 
1996
1946
    if (len < sizeof(*reply)) {
1997
1947
        return A_EINVAL;
2008
1958
                (tspec_ie->tsInfo_info >> TSPEC_TSID_S) & TSPEC_TSID_MASK);
2009
1959
    }
2010
1960
    else if (reply->cac_indication == CAC_INDICATION_NO_RESP) {
2011
 
        A_UINT8 i;
 
1961
        u8 i;
2012
1962
 
2013
1963
        /* following assumes that there is only one outstanding ADDTS request
2014
1964
           when this event is received */
2030
1980
         * for delete qos stream from AP
2031
1981
         */
2032
1982
    else if (reply->cac_indication == CAC_INDICATION_DELETE) {
2033
 
        A_UINT8 tsid = 0;
 
1983
        u8 tsid = 0;
2034
1984
 
2035
1985
        tspec_ie = (WMM_TSPEC_IE *) &(reply->tspecSuggestion);
2036
1986
        tsid= ((tspec_ie->tsInfo_info >> TSPEC_TSID_S) & TSPEC_TSID_MASK);
2053
2003
                reply->cac_indication, reply->statusCode,
2054
2004
                reply->tspecSuggestion);
2055
2005
 
2056
 
    return A_OK;
 
2006
    return 0;
2057
2007
}
2058
2008
 
2059
 
static A_STATUS
2060
 
wmi_channel_change_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2009
static int
 
2010
wmi_channel_change_event_rx(struct wmi_t *wmip, u8 *datap, int len)
2061
2011
{
2062
2012
    WMI_CHANNEL_CHANGE_EVENT *reply;
2063
2013
 
2070
2020
    A_WMI_CHANNEL_CHANGE_EVENT(wmip->wmi_devt, reply->oldChannel,
2071
2021
                               reply->newChannel);
2072
2022
 
2073
 
    return A_OK;
 
2023
    return 0;
2074
2024
}
2075
2025
 
2076
 
static A_STATUS
2077
 
wmi_hbChallengeResp_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2026
static int
 
2027
wmi_hbChallengeResp_rx(struct wmi_t *wmip, u8 *datap, int len)
2078
2028
{
2079
2029
    WMIX_HB_CHALLENGE_RESP_EVENT *reply;
2080
2030
 
2086
2036
 
2087
2037
    A_WMI_HBCHALLENGERESP_EVENT(wmip->wmi_devt, reply->cookie, reply->source);
2088
2038
 
2089
 
    return A_OK;
 
2039
    return 0;
2090
2040
}
2091
2041
 
2092
 
static A_STATUS
2093
 
wmi_roam_tbl_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2042
static int
 
2043
wmi_roam_tbl_event_rx(struct wmi_t *wmip, u8 *datap, int len)
2094
2044
{
2095
2045
    WMI_TARGET_ROAM_TBL *reply;
2096
2046
 
2102
2052
 
2103
2053
    A_WMI_ROAM_TABLE_EVENT(wmip->wmi_devt, reply);
2104
2054
 
2105
 
    return A_OK;
 
2055
    return 0;
2106
2056
}
2107
2057
 
2108
 
static A_STATUS
2109
 
wmi_roam_data_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2058
static int
 
2059
wmi_roam_data_event_rx(struct wmi_t *wmip, u8 *datap, int len)
2110
2060
{
2111
2061
    WMI_TARGET_ROAM_DATA *reply;
2112
2062
 
2118
2068
 
2119
2069
    A_WMI_ROAM_DATA_EVENT(wmip->wmi_devt, reply);
2120
2070
 
2121
 
    return A_OK;
 
2071
    return 0;
2122
2072
}
2123
2073
 
2124
 
static A_STATUS
2125
 
wmi_txRetryErrEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2074
static int
 
2075
wmi_txRetryErrEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
2126
2076
{
2127
2077
    if (len < sizeof(WMI_TX_RETRY_ERR_EVENT)) {
2128
2078
        return A_EINVAL;
2131
2081
 
2132
2082
    A_WMI_TX_RETRY_ERR_EVENT(wmip->wmi_devt);
2133
2083
 
2134
 
    return A_OK;
 
2084
    return 0;
2135
2085
}
2136
2086
 
2137
 
static A_STATUS
2138
 
wmi_snrThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2087
static int
 
2088
wmi_snrThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
2139
2089
{
2140
2090
    WMI_SNR_THRESHOLD_EVENT *reply;
2141
2091
    SQ_THRESHOLD_PARAMS *sq_thresh =
2142
2092
           &wmip->wmi_SqThresholdParams[SIGNAL_QUALITY_METRICS_SNR];
2143
2093
    WMI_SNR_THRESHOLD_VAL newThreshold;
2144
2094
    WMI_SNR_THRESHOLD_PARAMS_CMD cmd;
2145
 
    A_UINT8 upper_snr_threshold, lower_snr_threshold;
2146
 
    A_INT16 snr;
 
2095
    u8 upper_snr_threshold, lower_snr_threshold;
 
2096
    s16 snr;
2147
2097
 
2148
2098
    if (len < sizeof(*reply)) {
2149
2099
        return A_EINVAL;
2218
2168
 
2219
2169
    snr_event_value = snr;
2220
2170
 
2221
 
    if (wmi_send_snr_threshold_params(wmip, &cmd) != A_OK) {
 
2171
    if (wmi_send_snr_threshold_params(wmip, &cmd) != 0) {
2222
2172
        A_DPRINTF(DBG_WMI, (DBGFMT "Unable to configure the SNR thresholds\n",
2223
2173
                  DBGARG));
2224
2174
    }
2225
2175
    A_WMI_SNR_THRESHOLD_EVENT_RX(wmip->wmi_devt, newThreshold, reply->snr);
2226
2176
 
2227
 
    return A_OK;
 
2177
    return 0;
2228
2178
}
2229
2179
 
2230
 
static A_STATUS
2231
 
wmi_lqThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2180
static int
 
2181
wmi_lqThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
2232
2182
{
2233
2183
    WMI_LQ_THRESHOLD_EVENT *reply;
2234
2184
 
2242
2192
                                (WMI_LQ_THRESHOLD_VAL) reply->range,
2243
2193
                                reply->lq);
2244
2194
 
2245
 
    return A_OK;
 
2195
    return 0;
2246
2196
}
2247
2197
 
2248
 
static A_STATUS
2249
 
wmi_aplistEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2198
static int
 
2199
wmi_aplistEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
2250
2200
{
2251
 
    A_UINT16 ap_info_entry_size;
 
2201
    u16 ap_info_entry_size;
2252
2202
    WMI_APLIST_EVENT *ev = (WMI_APLIST_EVENT *)datap;
2253
2203
    WMI_AP_INFO_V1 *ap_info_v1;
2254
 
    A_UINT8 i;
 
2204
    u8 i;
2255
2205
 
2256
2206
    if (len < sizeof(WMI_APLIST_EVENT)) {
2257
2207
        return A_EINVAL;
2283
2233
                   ap_info_v1->channel));
2284
2234
        ap_info_v1++;
2285
2235
    }
2286
 
    return A_OK;
 
2236
    return 0;
2287
2237
}
2288
2238
 
2289
 
static A_STATUS
2290
 
wmi_dbglog_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
2239
static int
 
2240
wmi_dbglog_event_rx(struct wmi_t *wmip, u8 *datap, int len)
2291
2241
{
2292
 
    A_UINT32 dropped;
 
2242
    u32 dropped;
2293
2243
 
2294
 
    dropped = *((A_UINT32 *)datap);
 
2244
    dropped = *((u32 *)datap);
2295
2245
    datap += sizeof(dropped);
2296
2246
    len -= sizeof(dropped);
2297
 
    A_WMI_DBGLOG_EVENT(wmip->wmi_devt, dropped, (A_INT8*)datap, len);
2298
 
    return A_OK;
2299
 
}
2300
 
 
2301
 
#ifdef CONFIG_HOST_GPIO_SUPPORT
2302
 
static A_STATUS
2303
 
wmi_gpio_intr_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
2304
 
{
2305
 
    WMIX_GPIO_INTR_EVENT *gpio_intr = (WMIX_GPIO_INTR_EVENT *)datap;
2306
 
 
2307
 
    A_DPRINTF(DBG_WMI,
2308
 
        (DBGFMT "Enter - intrmask=0x%x input=0x%x.\n", DBGARG,
2309
 
        gpio_intr->intr_mask, gpio_intr->input_values));
2310
 
 
2311
 
    A_WMI_GPIO_INTR_RX(gpio_intr->intr_mask, gpio_intr->input_values);
2312
 
 
2313
 
    return A_OK;
2314
 
}
2315
 
 
2316
 
static A_STATUS
2317
 
wmi_gpio_data_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
2318
 
{
2319
 
    WMIX_GPIO_DATA_EVENT *gpio_data = (WMIX_GPIO_DATA_EVENT *)datap;
2320
 
 
2321
 
    A_DPRINTF(DBG_WMI,
2322
 
        (DBGFMT "Enter - reg=%d value=0x%x\n", DBGARG,
2323
 
        gpio_data->reg_id, gpio_data->value));
2324
 
 
2325
 
    A_WMI_GPIO_DATA_RX(gpio_data->reg_id, gpio_data->value);
2326
 
 
2327
 
    return A_OK;
2328
 
}
2329
 
 
2330
 
static A_STATUS
2331
 
wmi_gpio_ack_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
2332
 
{
2333
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
2334
 
 
2335
 
    A_WMI_GPIO_ACK_RX();
2336
 
 
2337
 
    return A_OK;
2338
 
}
2339
 
#endif /* CONFIG_HOST_GPIO_SUPPORT */
 
2247
    A_WMI_DBGLOG_EVENT(wmip->wmi_devt, dropped, (s8 *)datap, len);
 
2248
    return 0;
 
2249
}
2340
2250
 
2341
2251
/*
2342
2252
 * Called to send a wmi command. Command specific data is already built
2343
2253
 * on osbuf and current osbuf->data points to it.
2344
2254
 */
2345
 
A_STATUS
 
2255
int
2346
2256
wmi_cmd_send(struct wmi_t *wmip, void *osbuf, WMI_COMMAND_ID cmdId,
2347
2257
               WMI_SYNC_FLAG syncflag)
2348
2258
{
2349
 
    A_STATUS status;
 
2259
    int status;
2350
2260
#define IS_OPT_TX_CMD(cmdId) ((cmdId == WMI_OPT_TX_FRAME_CMDID))
2351
2261
    WMI_CMD_HDR         *cHdr;
2352
2262
    HTC_ENDPOINT_ID     eid  = wmip->wmi_endpoint_id;
2366
2276
        wmi_sync_point(wmip);
2367
2277
    }
2368
2278
 
2369
 
    if (A_NETBUF_PUSH(osbuf, sizeof(WMI_CMD_HDR)) != A_OK) {
 
2279
    if (A_NETBUF_PUSH(osbuf, sizeof(WMI_CMD_HDR)) != 0) {
2370
2280
        A_NETBUF_FREE(osbuf);
2371
2281
        return A_NO_MEMORY;
2372
2282
    }
2373
2283
 
2374
2284
    cHdr = (WMI_CMD_HDR *)A_NETBUF_DATA(osbuf);
2375
 
    cHdr->commandId = (A_UINT16) cmdId;
 
2285
    cHdr->commandId = (u16) cmdId;
2376
2286
    cHdr->info1 = 0; // added for virtual interface
2377
2287
 
2378
2288
    /*
2379
2289
     * Only for OPT_TX_CMD, use BE endpoint.
2380
2290
     */
2381
2291
    if (IS_OPT_TX_CMD(cmdId)) {
2382
 
        if ((status=wmi_data_hdr_add(wmip, osbuf, OPT_MSGTYPE, FALSE, FALSE,0,NULL)) != A_OK) {
 
2292
        if ((status=wmi_data_hdr_add(wmip, osbuf, OPT_MSGTYPE, false, false,0,NULL)) != 0) {
2383
2293
            A_NETBUF_FREE(osbuf);
2384
2294
            return status;
2385
2295
        }
2394
2304
         */
2395
2305
        wmi_sync_point(wmip);
2396
2306
    }
2397
 
    return (A_OK);
 
2307
    return (0);
2398
2308
#undef IS_OPT_TX_CMD
2399
2309
}
2400
2310
 
2401
 
A_STATUS
 
2311
int
2402
2312
wmi_cmd_send_xtnd(struct wmi_t *wmip, void *osbuf, WMIX_COMMAND_ID cmdId,
2403
2313
                  WMI_SYNC_FLAG syncflag)
2404
2314
{
2405
2315
    WMIX_CMD_HDR     *cHdr;
2406
2316
 
2407
 
    if (A_NETBUF_PUSH(osbuf, sizeof(WMIX_CMD_HDR)) != A_OK) {
 
2317
    if (A_NETBUF_PUSH(osbuf, sizeof(WMIX_CMD_HDR)) != 0) {
2408
2318
        A_NETBUF_FREE(osbuf);
2409
2319
        return A_NO_MEMORY;
2410
2320
    }
2411
2321
 
2412
2322
    cHdr = (WMIX_CMD_HDR *)A_NETBUF_DATA(osbuf);
2413
 
    cHdr->commandId = (A_UINT32) cmdId;
 
2323
    cHdr->commandId = (u32) cmdId;
2414
2324
 
2415
2325
    return wmi_cmd_send(wmip, osbuf, WMI_EXTENSION_CMDID, syncflag);
2416
2326
}
2417
2327
 
2418
 
A_STATUS
 
2328
int
2419
2329
wmi_connect_cmd(struct wmi_t *wmip, NETWORK_TYPE netType,
2420
2330
                DOT11_AUTH_MODE dot11AuthMode, AUTH_MODE authMode,
2421
 
                CRYPTO_TYPE pairwiseCrypto, A_UINT8 pairwiseCryptoLen,
2422
 
                CRYPTO_TYPE groupCrypto, A_UINT8 groupCryptoLen,
2423
 
                int ssidLength, A_UCHAR *ssid,
2424
 
                A_UINT8 *bssid, A_UINT16 channel, A_UINT32 ctrl_flags)
 
2331
                CRYPTO_TYPE pairwiseCrypto, u8 pairwiseCryptoLen,
 
2332
                CRYPTO_TYPE groupCrypto, u8 groupCryptoLen,
 
2333
                int ssidLength, u8 *ssid,
 
2334
                u8 *bssid, u16 channel, u32 ctrl_flags)
2425
2335
{
2426
2336
    void *osbuf;
2427
2337
    WMI_CONNECT_CMD *cc;
2446
2356
 
2447
2357
    if (ssidLength)
2448
2358
    {
2449
 
        A_MEMCPY(cc->ssid, ssid, ssidLength);
 
2359
        memcpy(cc->ssid, ssid, ssidLength);
2450
2360
    }
2451
2361
 
2452
2362
    cc->ssidLength          = ssidLength;
2461
2371
    cc->ctrl_flags          = ctrl_flags;
2462
2372
 
2463
2373
    if (bssid != NULL) {
2464
 
        A_MEMCPY(cc->bssid, bssid, ATH_MAC_LEN);
 
2374
        memcpy(cc->bssid, bssid, ATH_MAC_LEN);
2465
2375
    }
2466
2376
 
2467
2377
    wmip->wmi_pair_crypto_type  = pairwiseCrypto;
2470
2380
    return (wmi_cmd_send(wmip, osbuf, WMI_CONNECT_CMDID, NO_SYNC_WMIFLAG));
2471
2381
}
2472
2382
 
2473
 
A_STATUS
2474
 
wmi_reconnect_cmd(struct wmi_t *wmip, A_UINT8 *bssid, A_UINT16 channel)
 
2383
int
 
2384
wmi_reconnect_cmd(struct wmi_t *wmip, u8 *bssid, u16 channel)
2475
2385
{
2476
2386
    void *osbuf;
2477
2387
    WMI_RECONNECT_CMD *cc;
2490
2400
    cc->channel = channel;
2491
2401
 
2492
2402
    if (bssid != NULL) {
2493
 
        A_MEMCPY(cc->bssid, bssid, ATH_MAC_LEN);
 
2403
        memcpy(cc->bssid, bssid, ATH_MAC_LEN);
2494
2404
    }
2495
2405
 
2496
2406
    return (wmi_cmd_send(wmip, osbuf, WMI_RECONNECT_CMDID, NO_SYNC_WMIFLAG));
2497
2407
}
2498
2408
 
2499
 
A_STATUS
 
2409
int
2500
2410
wmi_disconnect_cmd(struct wmi_t *wmip)
2501
2411
{
2502
 
    A_STATUS status;
 
2412
    int status;
2503
2413
    wmip->wmi_traffic_class = 100;
2504
2414
 
2505
2415
    /* Bug fix for 24817(elevator bug) - the disconnect command does not
2509
2419
    return status;
2510
2420
}
2511
2421
 
2512
 
A_STATUS
 
2422
int
2513
2423
wmi_startscan_cmd(struct wmi_t *wmip, WMI_SCAN_TYPE scanType,
2514
 
                  A_BOOL forceFgScan, A_BOOL isLegacy,
2515
 
                  A_UINT32 homeDwellTime, A_UINT32 forceScanInterval,
2516
 
                  A_INT8 numChan, A_UINT16 *channelList)
 
2424
                  u32 forceFgScan, u32 isLegacy,
 
2425
                  u32 homeDwellTime, u32 forceScanInterval,
 
2426
                  s8 numChan, u16 *channelList)
2517
2427
{
2518
2428
    void *osbuf;
2519
2429
    WMI_START_SCAN_CMD *sc;
2520
 
    A_INT8 size;
 
2430
    s8 size;
2521
2431
 
2522
2432
    size = sizeof (*sc);
2523
2433
 
2529
2439
        if (numChan > WMI_MAX_CHANNELS) {
2530
2440
            return A_EINVAL;
2531
2441
        }
2532
 
        size += sizeof(A_UINT16) * (numChan - 1);
 
2442
        size += sizeof(u16) * (numChan - 1);
2533
2443
    }
2534
2444
 
2535
2445
    osbuf = A_NETBUF_ALLOC(size);
2547
2457
    sc->forceScanInterval = forceScanInterval;
2548
2458
    sc->numChannels = numChan;
2549
2459
    if (numChan) {
2550
 
        A_MEMCPY(sc->channelList, channelList, numChan * sizeof(A_UINT16));
 
2460
        memcpy(sc->channelList, channelList, numChan * sizeof(u16));
2551
2461
    }
2552
2462
 
2553
2463
    return (wmi_cmd_send(wmip, osbuf, WMI_START_SCAN_CMDID, NO_SYNC_WMIFLAG));
2554
2464
}
2555
2465
 
2556
 
A_STATUS
2557
 
wmi_scanparams_cmd(struct wmi_t *wmip, A_UINT16 fg_start_sec,
2558
 
                   A_UINT16 fg_end_sec, A_UINT16 bg_sec,
2559
 
                   A_UINT16 minact_chdw_msec, A_UINT16 maxact_chdw_msec,
2560
 
                   A_UINT16 pas_chdw_msec,
2561
 
                   A_UINT8 shScanRatio, A_UINT8 scanCtrlFlags,
2562
 
                   A_UINT32 max_dfsch_act_time, A_UINT16 maxact_scan_per_ssid)
 
2466
int
 
2467
wmi_scanparams_cmd(struct wmi_t *wmip, u16 fg_start_sec,
 
2468
                   u16 fg_end_sec, u16 bg_sec,
 
2469
                   u16 minact_chdw_msec, u16 maxact_chdw_msec,
 
2470
                   u16 pas_chdw_msec,
 
2471
                   u8 shScanRatio, u8 scanCtrlFlags,
 
2472
                   u32 max_dfsch_act_time, u16 maxact_scan_per_ssid)
2563
2473
{
2564
2474
    void *osbuf;
2565
2475
    WMI_SCAN_PARAMS_CMD *sc;
2588
2498
                         NO_SYNC_WMIFLAG));
2589
2499
}
2590
2500
 
2591
 
A_STATUS
2592
 
wmi_bssfilter_cmd(struct wmi_t *wmip, A_UINT8 filter, A_UINT32 ieMask)
 
2501
int
 
2502
wmi_bssfilter_cmd(struct wmi_t *wmip, u8 filter, u32 ieMask)
2593
2503
{
2594
2504
    void *osbuf;
2595
2505
    WMI_BSS_FILTER_CMD *cmd;
2614
2524
                         NO_SYNC_WMIFLAG));
2615
2525
}
2616
2526
 
2617
 
A_STATUS
2618
 
wmi_probedSsid_cmd(struct wmi_t *wmip, A_UINT8 index, A_UINT8 flag,
2619
 
                   A_UINT8 ssidLength, A_UCHAR *ssid)
 
2527
int
 
2528
wmi_probedSsid_cmd(struct wmi_t *wmip, u8 index, u8 flag,
 
2529
                   u8 ssidLength, u8 *ssid)
2620
2530
{
2621
2531
    void *osbuf;
2622
2532
    WMI_PROBED_SSID_CMD *cmd;
2635
2545
    }
2636
2546
 
2637
2547
    if (flag & SPECIFIC_SSID_FLAG) {
2638
 
        is_probe_ssid = TRUE;
 
2548
        is_probe_ssid = true;
2639
2549
    }
2640
2550
 
2641
2551
    osbuf = A_NETBUF_ALLOC(sizeof(*cmd));
2650
2560
    cmd->entryIndex = index;
2651
2561
    cmd->flag       = flag;
2652
2562
    cmd->ssidLength = ssidLength;
2653
 
    A_MEMCPY(cmd->ssid, ssid, ssidLength);
 
2563
    memcpy(cmd->ssid, ssid, ssidLength);
2654
2564
 
2655
2565
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_PROBED_SSID_CMDID,
2656
2566
                         NO_SYNC_WMIFLAG));
2657
2567
}
2658
2568
 
2659
 
A_STATUS
2660
 
wmi_listeninterval_cmd(struct wmi_t *wmip, A_UINT16 listenInterval, A_UINT16 listenBeacons)
 
2569
int
 
2570
wmi_listeninterval_cmd(struct wmi_t *wmip, u16 listenInterval, u16 listenBeacons)
2661
2571
{
2662
2572
    void *osbuf;
2663
2573
    WMI_LISTEN_INT_CMD *cmd;
2678
2588
                         NO_SYNC_WMIFLAG));
2679
2589
}
2680
2590
 
2681
 
A_STATUS
2682
 
wmi_bmisstime_cmd(struct wmi_t *wmip, A_UINT16 bmissTime, A_UINT16 bmissBeacons)
 
2591
int
 
2592
wmi_bmisstime_cmd(struct wmi_t *wmip, u16 bmissTime, u16 bmissBeacons)
2683
2593
{
2684
2594
    void *osbuf;
2685
2595
    WMI_BMISS_TIME_CMD *cmd;
2700
2610
                         NO_SYNC_WMIFLAG));
2701
2611
}
2702
2612
 
2703
 
A_STATUS
2704
 
wmi_associnfo_cmd(struct wmi_t *wmip, A_UINT8 ieType,
2705
 
                     A_UINT8 ieLen, A_UINT8 *ieInfo)
 
2613
int
 
2614
wmi_associnfo_cmd(struct wmi_t *wmip, u8 ieType,
 
2615
                     u8 ieLen, u8 *ieInfo)
2706
2616
{
2707
2617
    void *osbuf;
2708
2618
    WMI_SET_ASSOC_INFO_CMD *cmd;
2709
 
    A_UINT16 cmdLen;
 
2619
    u16 cmdLen;
2710
2620
 
2711
2621
    cmdLen = sizeof(*cmd) + ieLen - 1;
2712
2622
    osbuf = A_NETBUF_ALLOC(cmdLen);
2720
2630
    A_MEMZERO(cmd, cmdLen);
2721
2631
    cmd->ieType = ieType;
2722
2632
    cmd->bufferSize = ieLen;
2723
 
    A_MEMCPY(cmd->assocInfo, ieInfo, ieLen);
 
2633
    memcpy(cmd->assocInfo, ieInfo, ieLen);
2724
2634
 
2725
2635
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_ASSOC_INFO_CMDID,
2726
2636
                         NO_SYNC_WMIFLAG));
2727
2637
}
2728
2638
 
2729
 
A_STATUS
2730
 
wmi_powermode_cmd(struct wmi_t *wmip, A_UINT8 powerMode)
 
2639
int
 
2640
wmi_powermode_cmd(struct wmi_t *wmip, u8 powerMode)
2731
2641
{
2732
2642
    void *osbuf;
2733
2643
    WMI_POWER_MODE_CMD *cmd;
2748
2658
                         NO_SYNC_WMIFLAG));
2749
2659
}
2750
2660
 
2751
 
A_STATUS
2752
 
wmi_ibsspmcaps_cmd(struct wmi_t *wmip, A_UINT8 pmEnable, A_UINT8 ttl,
2753
 
                   A_UINT16 atim_windows, A_UINT16 timeout_value)
 
2661
int
 
2662
wmi_ibsspmcaps_cmd(struct wmi_t *wmip, u8 pmEnable, u8 ttl,
 
2663
                   u16 atim_windows, u16 timeout_value)
2754
2664
{
2755
2665
    void *osbuf;
2756
2666
    WMI_IBSS_PM_CAPS_CMD *cmd;
2773
2683
                         NO_SYNC_WMIFLAG));
2774
2684
}
2775
2685
 
2776
 
A_STATUS
2777
 
wmi_apps_cmd(struct wmi_t *wmip, A_UINT8 psType, A_UINT32 idle_time,
2778
 
                   A_UINT32 ps_period, A_UINT8 sleep_period)
 
2686
int
 
2687
wmi_apps_cmd(struct wmi_t *wmip, u8 psType, u32 idle_time,
 
2688
                   u32 ps_period, u8 sleep_period)
2779
2689
{
2780
2690
    void *osbuf;
2781
2691
    WMI_AP_PS_CMD *cmd;
2798
2708
                         NO_SYNC_WMIFLAG));
2799
2709
}
2800
2710
 
2801
 
A_STATUS
2802
 
wmi_pmparams_cmd(struct wmi_t *wmip, A_UINT16 idlePeriod,
2803
 
                 A_UINT16 psPollNum, A_UINT16 dtimPolicy,
2804
 
                 A_UINT16 tx_wakeup_policy, A_UINT16 num_tx_to_wakeup,
2805
 
                 A_UINT16 ps_fail_event_policy)
 
2711
int
 
2712
wmi_pmparams_cmd(struct wmi_t *wmip, u16 idlePeriod,
 
2713
                 u16 psPollNum, u16 dtimPolicy,
 
2714
                 u16 tx_wakeup_policy, u16 num_tx_to_wakeup,
 
2715
                 u16 ps_fail_event_policy)
2806
2716
{
2807
2717
    void *osbuf;
2808
2718
    WMI_POWER_PARAMS_CMD *pm;
2827
2737
                         NO_SYNC_WMIFLAG));
2828
2738
}
2829
2739
 
2830
 
A_STATUS
2831
 
wmi_disctimeout_cmd(struct wmi_t *wmip, A_UINT8 timeout)
 
2740
int
 
2741
wmi_disctimeout_cmd(struct wmi_t *wmip, u8 timeout)
2832
2742
{
2833
2743
    void *osbuf;
2834
2744
    WMI_DISC_TIMEOUT_CMD *cmd;
2848
2758
                         NO_SYNC_WMIFLAG));
2849
2759
}
2850
2760
 
2851
 
A_STATUS
2852
 
wmi_addKey_cmd(struct wmi_t *wmip, A_UINT8 keyIndex, CRYPTO_TYPE keyType,
2853
 
               A_UINT8 keyUsage, A_UINT8 keyLength, A_UINT8 *keyRSC,
2854
 
               A_UINT8 *keyMaterial, A_UINT8 key_op_ctrl, A_UINT8 *macAddr,
 
2761
int
 
2762
wmi_addKey_cmd(struct wmi_t *wmip, u8 keyIndex, CRYPTO_TYPE keyType,
 
2763
               u8 keyUsage, u8 keyLength, u8 *keyRSC,
 
2764
               u8 *keyMaterial, u8 key_op_ctrl, u8 *macAddr,
2855
2765
               WMI_SYNC_FLAG sync_flag)
2856
2766
{
2857
2767
    void *osbuf;
2880
2790
    cmd->keyType  = keyType;
2881
2791
    cmd->keyUsage = keyUsage;
2882
2792
    cmd->keyLength = keyLength;
2883
 
    A_MEMCPY(cmd->key, keyMaterial, keyLength);
 
2793
    memcpy(cmd->key, keyMaterial, keyLength);
2884
2794
#ifdef WAPI_ENABLE
2885
2795
    if (NULL != keyRSC && key_op_ctrl != KEY_OP_INIT_WAPIPN) {
2886
2796
#else
2887
2797
    if (NULL != keyRSC) {
2888
2798
#endif // WAPI_ENABLE
2889
 
        A_MEMCPY(cmd->keyRSC, keyRSC, sizeof(cmd->keyRSC));
 
2799
        memcpy(cmd->keyRSC, keyRSC, sizeof(cmd->keyRSC));
2890
2800
    }
2891
2801
    cmd->key_op_ctrl = key_op_ctrl;
2892
2802
 
2893
2803
    if(macAddr) {
2894
 
        A_MEMCPY(cmd->key_macaddr,macAddr,IEEE80211_ADDR_LEN);
 
2804
        memcpy(cmd->key_macaddr,macAddr,IEEE80211_ADDR_LEN);
2895
2805
    }
2896
2806
 
2897
2807
    return (wmi_cmd_send(wmip, osbuf, WMI_ADD_CIPHER_KEY_CMDID, sync_flag));
2898
2808
}
2899
2809
 
2900
 
A_STATUS
2901
 
wmi_add_krk_cmd(struct wmi_t *wmip, A_UINT8 *krk)
 
2810
int
 
2811
wmi_add_krk_cmd(struct wmi_t *wmip, u8 *krk)
2902
2812
{
2903
2813
    void *osbuf;
2904
2814
    WMI_ADD_KRK_CMD *cmd;
2912
2822
 
2913
2823
    cmd = (WMI_ADD_KRK_CMD *)(A_NETBUF_DATA(osbuf));
2914
2824
    A_MEMZERO(cmd, sizeof(*cmd));
2915
 
    A_MEMCPY(cmd->krk, krk, WMI_KRK_LEN);
 
2825
    memcpy(cmd->krk, krk, WMI_KRK_LEN);
2916
2826
 
2917
2827
    return (wmi_cmd_send(wmip, osbuf, WMI_ADD_KRK_CMDID, NO_SYNC_WMIFLAG));
2918
2828
}
2919
2829
 
2920
 
A_STATUS
 
2830
int
2921
2831
wmi_delete_krk_cmd(struct wmi_t *wmip)
2922
2832
{
2923
2833
    return wmi_simple_cmd(wmip, WMI_DELETE_KRK_CMDID);
2924
2834
}
2925
2835
 
2926
 
A_STATUS
2927
 
wmi_deleteKey_cmd(struct wmi_t *wmip, A_UINT8 keyIndex)
 
2836
int
 
2837
wmi_deleteKey_cmd(struct wmi_t *wmip, u8 keyIndex)
2928
2838
{
2929
2839
    void *osbuf;
2930
2840
    WMI_DELETE_CIPHER_KEY_CMD *cmd;
2948
2858
                         NO_SYNC_WMIFLAG));
2949
2859
}
2950
2860
 
2951
 
A_STATUS
2952
 
wmi_setPmkid_cmd(struct wmi_t *wmip, A_UINT8 *bssid, A_UINT8 *pmkId,
2953
 
                 A_BOOL set)
 
2861
int
 
2862
wmi_setPmkid_cmd(struct wmi_t *wmip, u8 *bssid, u8 *pmkId,
 
2863
                 bool set)
2954
2864
{
2955
2865
    void *osbuf;
2956
2866
    WMI_SET_PMKID_CMD *cmd;
2959
2869
        return A_EINVAL;
2960
2870
    }
2961
2871
 
2962
 
    if ((set == TRUE) && (pmkId == NULL)) {
 
2872
    if ((set == true) && (pmkId == NULL)) {
2963
2873
        return A_EINVAL;
2964
2874
    }
2965
2875
 
2971
2881
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
2972
2882
 
2973
2883
    cmd = (WMI_SET_PMKID_CMD *)(A_NETBUF_DATA(osbuf));
2974
 
    A_MEMCPY(cmd->bssid, bssid, sizeof(cmd->bssid));
2975
 
    if (set == TRUE) {
2976
 
        A_MEMCPY(cmd->pmkid, pmkId, sizeof(cmd->pmkid));
 
2884
    memcpy(cmd->bssid, bssid, sizeof(cmd->bssid));
 
2885
    if (set == true) {
 
2886
        memcpy(cmd->pmkid, pmkId, sizeof(cmd->pmkid));
2977
2887
        cmd->enable = PMKID_ENABLE;
2978
2888
    } else {
2979
2889
        A_MEMZERO(cmd->pmkid, sizeof(cmd->pmkid));
2983
2893
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_PMKID_CMDID, NO_SYNC_WMIFLAG));
2984
2894
}
2985
2895
 
2986
 
A_STATUS
2987
 
wmi_set_tkip_countermeasures_cmd(struct wmi_t *wmip, A_BOOL en)
 
2896
int
 
2897
wmi_set_tkip_countermeasures_cmd(struct wmi_t *wmip, bool en)
2988
2898
{
2989
2899
    void *osbuf;
2990
2900
    WMI_SET_TKIP_COUNTERMEASURES_CMD *cmd;
2997
2907
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
2998
2908
 
2999
2909
    cmd = (WMI_SET_TKIP_COUNTERMEASURES_CMD *)(A_NETBUF_DATA(osbuf));
3000
 
    cmd->cm_en = (en == TRUE)? WMI_TKIP_CM_ENABLE : WMI_TKIP_CM_DISABLE;
 
2910
    cmd->cm_en = (en == true)? WMI_TKIP_CM_ENABLE : WMI_TKIP_CM_DISABLE;
3001
2911
 
3002
2912
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_TKIP_COUNTERMEASURES_CMDID,
3003
2913
            NO_SYNC_WMIFLAG));
3004
2914
}
3005
2915
 
3006
 
A_STATUS
 
2916
int
3007
2917
wmi_set_akmp_params_cmd(struct wmi_t *wmip,
3008
2918
                        WMI_SET_AKMP_PARAMS_CMD *akmpParams)
3009
2919
{
3023
2933
            NO_SYNC_WMIFLAG));
3024
2934
}
3025
2935
 
3026
 
A_STATUS
 
2936
int
3027
2937
wmi_set_pmkid_list_cmd(struct wmi_t *wmip,
3028
2938
                       WMI_SET_PMKID_LIST_CMD *pmkInfo)
3029
2939
{
3030
2940
    void *osbuf;
3031
2941
    WMI_SET_PMKID_LIST_CMD *cmd;
3032
 
    A_UINT16 cmdLen;
3033
 
    A_UINT8 i;
 
2942
    u16 cmdLen;
 
2943
    u8 i;
3034
2944
 
3035
2945
    cmdLen = sizeof(pmkInfo->numPMKID) +
3036
2946
             pmkInfo->numPMKID * sizeof(WMI_PMKID);
3045
2955
    cmd->numPMKID = pmkInfo->numPMKID;
3046
2956
 
3047
2957
    for (i = 0; i < cmd->numPMKID; i++) {
3048
 
        A_MEMCPY(&cmd->pmkidList[i], &pmkInfo->pmkidList[i],
 
2958
        memcpy(&cmd->pmkidList[i], &pmkInfo->pmkidList[i],
3049
2959
                 WMI_PMKID_LEN);
3050
2960
    }
3051
2961
 
3053
2963
            NO_SYNC_WMIFLAG));
3054
2964
}
3055
2965
 
3056
 
A_STATUS
 
2966
int
3057
2967
wmi_get_pmkid_list_cmd(struct wmi_t *wmip)
3058
2968
{
3059
2969
    return wmi_simple_cmd(wmip, WMI_GET_PMKID_LIST_CMDID);
3060
2970
}
3061
2971
 
3062
 
A_STATUS
 
2972
int
3063
2973
wmi_dataSync_send(struct wmi_t *wmip, void *osbuf, HTC_ENDPOINT_ID eid)
3064
2974
{
3065
2975
    WMI_DATA_HDR     *dtHdr;
3067
2977
    A_ASSERT( eid != wmip->wmi_endpoint_id);
3068
2978
    A_ASSERT(osbuf != NULL);
3069
2979
 
3070
 
    if (A_NETBUF_PUSH(osbuf, sizeof(WMI_DATA_HDR)) != A_OK) {
 
2980
    if (A_NETBUF_PUSH(osbuf, sizeof(WMI_DATA_HDR)) != 0) {
3071
2981
        return A_NO_MEMORY;
3072
2982
    }
3073
2983
 
3075
2985
    dtHdr->info =
3076
2986
      (SYNC_MSGTYPE & WMI_DATA_HDR_MSG_TYPE_MASK) << WMI_DATA_HDR_MSG_TYPE_SHIFT;
3077
2987
 
 
2988
    dtHdr->info3 = 0;
3078
2989
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter - eid %d\n", DBGARG, eid));
3079
2990
 
3080
2991
    return (A_WMI_CONTROL_TX(wmip->wmi_devt, osbuf, eid));
3081
2992
}
3082
2993
 
3083
2994
typedef struct _WMI_DATA_SYNC_BUFS {
3084
 
    A_UINT8            trafficClass;
 
2995
    u8 trafficClass;
3085
2996
    void               *osbuf;
3086
2997
}WMI_DATA_SYNC_BUFS;
3087
2998
 
3088
 
static A_STATUS
 
2999
static int
3089
3000
wmi_sync_point(struct wmi_t *wmip)
3090
3001
{
3091
3002
    void *cmd_osbuf;
3092
3003
    WMI_SYNC_CMD *cmd;
3093
3004
    WMI_DATA_SYNC_BUFS dataSyncBufs[WMM_NUM_AC];
3094
 
    A_UINT8 i,numPriStreams=0;
3095
 
    A_STATUS status = A_OK;
 
3005
    u8 i,numPriStreams=0;
 
3006
    int status = 0;
3096
3007
 
3097
3008
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
3098
3009
 
3144
3055
        /* if Buffer allocation for any of the dataSync fails, then do not
3145
3056
         * send the Synchronize cmd on the control ep
3146
3057
         */
3147
 
        if (A_FAILED(status)) {
 
3058
        if (status) {
3148
3059
            break;
3149
3060
        }
3150
3061
 
3155
3066
    status = wmi_cmd_send(wmip, cmd_osbuf, WMI_SYNCHRONIZE_CMDID,
3156
3067
                          NO_SYNC_WMIFLAG);
3157
3068
 
3158
 
        if (A_FAILED(status)) {
 
3069
        if (status) {
3159
3070
            break;
3160
3071
    }
3161
3072
            /* cmd buffer sent, we no longer own it */
3170
3081
                                                            trafficClass)
3171
3082
                                      );
3172
3083
 
3173
 
            if (A_FAILED(status)) {
 
3084
            if (status) {
3174
3085
                break;
3175
3086
            }
3176
3087
            /* we don't own this buffer anymore, NULL it out of the array so it
3178
3089
            dataSyncBufs[i].osbuf = NULL;
3179
3090
        } //end for
3180
3091
 
3181
 
    } while(FALSE);
 
3092
    } while(false);
3182
3093
 
3183
3094
    /* free up any resources left over (possibly due to an error) */
3184
3095
 
3195
3106
    return (status);
3196
3107
}
3197
3108
 
3198
 
A_STATUS
 
3109
int
3199
3110
wmi_create_pstream_cmd(struct wmi_t *wmip, WMI_CREATE_PSTREAM_CMD *params)
3200
3111
{
3201
3112
    void *osbuf;
3202
3113
    WMI_CREATE_PSTREAM_CMD *cmd;
3203
 
    A_UINT8 fatPipeExistsForAC=0;
3204
 
    A_INT32 minimalPHY = 0;
3205
 
    A_INT32 nominalPHY = 0;
 
3114
    u8 fatPipeExistsForAC=0;
 
3115
    s32 minimalPHY = 0;
 
3116
    s32 nominalPHY = 0;
3206
3117
 
3207
3118
    /* Validate all the parameters. */
3208
3119
    if( !((params->userPriority < 8) &&
3258
3169
 
3259
3170
    cmd = (WMI_CREATE_PSTREAM_CMD *)(A_NETBUF_DATA(osbuf));
3260
3171
    A_MEMZERO(cmd, sizeof(*cmd));
3261
 
    A_MEMCPY(cmd, params, sizeof(*cmd));
 
3172
    memcpy(cmd, params, sizeof(*cmd));
3262
3173
 
3263
3174
        /* this is an implicitly created Fat pipe */
3264
 
    if ((A_UINT32)params->tsid == (A_UINT32)WMI_IMPLICIT_PSTREAM) {
 
3175
    if ((u32)params->tsid == (u32)WMI_IMPLICIT_PSTREAM) {
3265
3176
        LOCK_WMI(wmip);
3266
3177
        fatPipeExistsForAC = (wmip->wmi_fatPipeExists & (1 << params->trafficClass));
3267
3178
        wmip->wmi_fatPipeExists |= (1<<params->trafficClass);
3291
3202
                         NO_SYNC_WMIFLAG));
3292
3203
}
3293
3204
 
3294
 
A_STATUS
3295
 
wmi_delete_pstream_cmd(struct wmi_t *wmip, A_UINT8 trafficClass, A_UINT8 tsid)
 
3205
int
 
3206
wmi_delete_pstream_cmd(struct wmi_t *wmip, u8 trafficClass, u8 tsid)
3296
3207
{
3297
3208
    void *osbuf;
3298
3209
    WMI_DELETE_PSTREAM_CMD *cmd;
3299
 
    A_STATUS status;
3300
 
    A_UINT16 activeTsids=0;
 
3210
    int status;
 
3211
    u16 activeTsids=0;
3301
3212
 
3302
3213
    /* validate the parameters */
3303
3214
    if (trafficClass > 3) {
3355
3266
    return status;
3356
3267
}
3357
3268
 
3358
 
A_STATUS
3359
 
wmi_set_framerate_cmd(struct wmi_t *wmip, A_UINT8 bEnable, A_UINT8 type, A_UINT8 subType, A_UINT16 rateMask)
 
3269
int
 
3270
wmi_set_framerate_cmd(struct wmi_t *wmip, u8 bEnable, u8 type, u8 subType, u16 rateMask)
3360
3271
{
3361
3272
    void *osbuf;
3362
3273
    WMI_FRAME_RATES_CMD *cmd;
3363
 
    A_UINT8 frameType;
 
3274
    u8 frameType;
3364
3275
 
3365
3276
    A_DPRINTF(DBG_WMI,
3366
3277
        (DBGFMT " type %02X, subType %02X, rateMask %04x\n", DBGARG, type, subType, rateMask));
3381
3292
    cmd = (WMI_FRAME_RATES_CMD *)(A_NETBUF_DATA(osbuf));
3382
3293
    A_MEMZERO(cmd, sizeof(*cmd));
3383
3294
 
3384
 
    frameType = (A_UINT8)((subType << 4) | type);
 
3295
    frameType = (u8)((subType << 4) | type);
3385
3296
 
3386
3297
    cmd->bEnableMask = bEnable;
3387
3298
    cmd->frameType = frameType;
3394
3305
 * used to set the bit rate.  rate is in Kbps.  If rate == -1
3395
3306
 * then auto selection is used.
3396
3307
 */
3397
 
A_STATUS
3398
 
wmi_set_bitrate_cmd(struct wmi_t *wmip, A_INT32 dataRate, A_INT32 mgmtRate, A_INT32 ctlRate)
 
3308
int
 
3309
wmi_set_bitrate_cmd(struct wmi_t *wmip, s32 dataRate, s32 mgmtRate, s32 ctlRate)
3399
3310
{
3400
3311
    void *osbuf;
3401
3312
    WMI_BIT_RATE_CMD *cmd;
3402
 
    A_INT8 drix, mrix, crix, ret_val;
 
3313
    s8 drix, mrix, crix, ret_val;
3403
3314
 
3404
3315
    if (dataRate != -1) {
3405
3316
        ret_val = wmi_validate_bitrate(wmip, dataRate, &drix);
3444
3355
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BITRATE_CMDID, NO_SYNC_WMIFLAG));
3445
3356
}
3446
3357
 
3447
 
A_STATUS
 
3358
int
3448
3359
wmi_get_bitrate_cmd(struct wmi_t *wmip)
3449
3360
{
3450
3361
    return wmi_simple_cmd(wmip, WMI_GET_BITRATE_CMDID);
3451
3362
}
3452
3363
 
3453
3364
/*
3454
 
 * Returns TRUE iff the given rate index is legal in the current PHY mode.
 
3365
 * Returns true iff the given rate index is legal in the current PHY mode.
3455
3366
 */
3456
 
A_BOOL
3457
 
wmi_is_bitrate_index_valid(struct wmi_t *wmip, A_INT32 rateIndex)
 
3367
bool
 
3368
wmi_is_bitrate_index_valid(struct wmi_t *wmip, s32 rateIndex)
3458
3369
{
3459
3370
    WMI_PHY_MODE phyMode = (WMI_PHY_MODE) wmip->wmi_phyMode;
3460
 
    A_BOOL isValid = TRUE;
 
3371
    bool isValid = true;
3461
3372
    switch(phyMode) {
3462
3373
        case WMI_11A_MODE:
3463
3374
            if (wmip->wmi_ht_allowed[A_BAND_5GHZ]){
3464
3375
                if ((rateIndex < MODE_A_SUPPORT_RATE_START) || (rateIndex > MODE_GHT20_SUPPORT_RATE_STOP)) {
3465
 
                    isValid = FALSE;
 
3376
                    isValid = false;
3466
3377
                }
3467
3378
            } else {
3468
3379
                if ((rateIndex < MODE_A_SUPPORT_RATE_START) || (rateIndex > MODE_A_SUPPORT_RATE_STOP)) {
3469
 
                    isValid = FALSE;
 
3380
                    isValid = false;
3470
3381
                }
3471
3382
            }
3472
3383
            break;
3473
3384
 
3474
3385
        case WMI_11B_MODE:
3475
3386
            if ((rateIndex < MODE_B_SUPPORT_RATE_START) || (rateIndex > MODE_B_SUPPORT_RATE_STOP)) {
3476
 
                isValid = FALSE;
 
3387
                isValid = false;
3477
3388
            }
3478
3389
            break;
3479
3390
 
3480
3391
        case WMI_11GONLY_MODE:
3481
3392
            if (wmip->wmi_ht_allowed[A_BAND_24GHZ]){
3482
3393
                if ((rateIndex < MODE_GONLY_SUPPORT_RATE_START) || (rateIndex > MODE_GHT20_SUPPORT_RATE_STOP)) {
3483
 
                    isValid = FALSE;
 
3394
                    isValid = false;
3484
3395
                }
3485
3396
            } else {
3486
3397
                if ((rateIndex < MODE_GONLY_SUPPORT_RATE_START) || (rateIndex > MODE_GONLY_SUPPORT_RATE_STOP)) {
3487
 
                    isValid = FALSE;
 
3398
                    isValid = false;
3488
3399
                }
3489
3400
            }
3490
3401
            break;
3493
3404
        case WMI_11AG_MODE:
3494
3405
            if (wmip->wmi_ht_allowed[A_BAND_24GHZ]){
3495
3406
                if ((rateIndex < MODE_G_SUPPORT_RATE_START) || (rateIndex > MODE_GHT20_SUPPORT_RATE_STOP)) {
3496
 
                    isValid = FALSE;
 
3407
                    isValid = false;
3497
3408
                }
3498
3409
            } else {
3499
3410
                if ((rateIndex < MODE_G_SUPPORT_RATE_START) || (rateIndex > MODE_G_SUPPORT_RATE_STOP)) {
3500
 
                    isValid = FALSE;
 
3411
                    isValid = false;
3501
3412
                }
3502
3413
            }
3503
3414
            break;
3504
3415
        default:
3505
 
            A_ASSERT(FALSE);
 
3416
            A_ASSERT(false);
3506
3417
            break;
3507
3418
    }
3508
3419
 
3509
3420
    return isValid;
3510
3421
}
3511
3422
 
3512
 
A_INT8
3513
 
wmi_validate_bitrate(struct wmi_t *wmip, A_INT32 rate, A_INT8 *rate_idx)
 
3423
s8 wmi_validate_bitrate(struct wmi_t *wmip, s32 rate, s8 *rate_idx)
3514
3424
{
3515
 
    A_INT8 i;
 
3425
    s8 i;
3516
3426
 
3517
3427
    for (i=0;;i++)
3518
3428
    {
3519
 
        if (wmi_rateTable[(A_UINT32) i][0] == 0) {
 
3429
        if (wmi_rateTable[(u32) i][0] == 0) {
3520
3430
            return A_EINVAL;
3521
3431
        }
3522
 
        if (wmi_rateTable[(A_UINT32) i][0] == rate) {
 
3432
        if (wmi_rateTable[(u32) i][0] == rate) {
3523
3433
            break;
3524
3434
        }
3525
3435
    }
3526
3436
 
3527
 
    if(wmi_is_bitrate_index_valid(wmip, (A_INT32) i) != TRUE) {
 
3437
    if(wmi_is_bitrate_index_valid(wmip, (s32) i) != true) {
3528
3438
        return A_EINVAL;
3529
3439
    }
3530
3440
 
3531
3441
    *rate_idx = i;
3532
 
    return A_OK;
 
3442
    return 0;
3533
3443
}
3534
3444
 
3535
 
A_STATUS
3536
 
wmi_set_fixrates_cmd(struct wmi_t *wmip, A_UINT32 fixRatesMask)
 
3445
int
 
3446
wmi_set_fixrates_cmd(struct wmi_t *wmip, u32 fixRatesMask)
3537
3447
{
3538
3448
    void *osbuf;
3539
3449
    WMI_FIX_RATES_CMD *cmd;
3540
3450
#if 0
3541
 
    A_INT32 rateIndex;
 
3451
    s32 rateIndex;
3542
3452
/* This check does not work for AR6003 as the HT modes are enabled only when
3543
3453
 * the STA is connected to a HT_BSS and is not based only on channel. It is
3544
3454
 * safe to skip this check however because rate control will only use rates
3547
3457
 * to be used. */
3548
3458
    /* Make sure all rates in the mask are valid in the current PHY mode */
3549
3459
    for(rateIndex = 0; rateIndex < MAX_NUMBER_OF_SUPPORT_RATES; rateIndex++) {
3550
 
       if((1 << rateIndex) & (A_UINT32)fixRatesMask) {
3551
 
            if(wmi_is_bitrate_index_valid(wmip, rateIndex) != TRUE) {
 
3460
       if((1 << rateIndex) & (u32)fixRatesMask) {
 
3461
            if(wmi_is_bitrate_index_valid(wmip, rateIndex) != true) {
3552
3462
                A_DPRINTF(DBG_WMI, (DBGFMT "Set Fix Rates command failed: Given rate is illegal in current PHY mode\n", DBGARG));
3553
3463
                return A_EINVAL;
3554
3464
            }
3572
3482
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_FIXRATES_CMDID, NO_SYNC_WMIFLAG));
3573
3483
}
3574
3484
 
3575
 
A_STATUS
 
3485
int
3576
3486
wmi_get_ratemask_cmd(struct wmi_t *wmip)
3577
3487
{
3578
3488
    return wmi_simple_cmd(wmip, WMI_GET_FIXRATES_CMDID);
3579
3489
}
3580
3490
 
3581
 
A_STATUS
 
3491
int
3582
3492
wmi_get_channelList_cmd(struct wmi_t *wmip)
3583
3493
{
3584
3494
    return wmi_simple_cmd(wmip, WMI_GET_CHANNEL_LIST_CMDID);
3594
3504
 * should limit its operation to.  It should be NULL if numChan == 0.  Size of
3595
3505
 * array should correspond to numChan entries.
3596
3506
 */
3597
 
A_STATUS
3598
 
wmi_set_channelParams_cmd(struct wmi_t *wmip, A_UINT8 scanParam,
3599
 
                          WMI_PHY_MODE mode, A_INT8 numChan,
3600
 
                          A_UINT16 *channelList)
 
3507
int
 
3508
wmi_set_channelParams_cmd(struct wmi_t *wmip, u8 scanParam,
 
3509
                          WMI_PHY_MODE mode, s8 numChan,
 
3510
                          u16 *channelList)
3601
3511
{
3602
3512
    void *osbuf;
3603
3513
    WMI_CHANNEL_PARAMS_CMD *cmd;
3604
 
    A_INT8 size;
 
3514
    s8 size;
3605
3515
 
3606
3516
    size = sizeof (*cmd);
3607
3517
 
3609
3519
        if (numChan > WMI_MAX_CHANNELS) {
3610
3520
            return A_EINVAL;
3611
3521
        }
3612
 
        size += sizeof(A_UINT16) * (numChan - 1);
 
3522
        size += sizeof(u16) * (numChan - 1);
3613
3523
    }
3614
3524
 
3615
3525
    osbuf = A_NETBUF_ALLOC(size);
3626
3536
    cmd->scanParam   = scanParam;
3627
3537
    cmd->phyMode     = mode;
3628
3538
    cmd->numChannels = numChan;
3629
 
    A_MEMCPY(cmd->channelList, channelList, numChan * sizeof(A_UINT16));
 
3539
    memcpy(cmd->channelList, channelList, numChan * sizeof(u16));
3630
3540
 
3631
3541
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_CHANNEL_PARAMS_CMDID,
3632
3542
                         NO_SYNC_WMIFLAG));
3681
3591
}
3682
3592
}
3683
3593
 
3684
 
A_STATUS
 
3594
int
3685
3595
wmi_set_rssi_threshold_params(struct wmi_t *wmip,
3686
3596
                              WMI_RSSI_THRESHOLD_PARAMS_CMD *rssiCmd)
3687
3597
{
3706
3616
    return (wmi_send_rssi_threshold_params(wmip, rssiCmd));
3707
3617
}
3708
3618
 
3709
 
A_STATUS
 
3619
int
3710
3620
wmi_set_ip_cmd(struct wmi_t *wmip, WMI_SET_IP_CMD *ipCmd)
3711
3621
{
3712
3622
    void    *osbuf;
3713
3623
    WMI_SET_IP_CMD *cmd;
3714
3624
 
3715
3625
    /* Multicast address are not valid */
3716
 
    if((*((A_UINT8*)&ipCmd->ips[0]) >= 0xE0) ||
3717
 
       (*((A_UINT8*)&ipCmd->ips[1]) >= 0xE0)) {
 
3626
    if((*((u8 *)&ipCmd->ips[0]) >= 0xE0) ||
 
3627
       (*((u8 *)&ipCmd->ips[1]) >= 0xE0)) {
3718
3628
        return A_EINVAL;
3719
3629
    }
3720
3630
 
3725
3635
 
3726
3636
    A_NETBUF_PUT(osbuf, sizeof(WMI_SET_IP_CMD));
3727
3637
    cmd = (WMI_SET_IP_CMD *)(A_NETBUF_DATA(osbuf));
3728
 
    A_MEMCPY(cmd, ipCmd, sizeof(WMI_SET_IP_CMD));
 
3638
    memcpy(cmd, ipCmd, sizeof(WMI_SET_IP_CMD));
3729
3639
 
3730
3640
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_IP_CMDID,
3731
3641
                            NO_SYNC_WMIFLAG));
3732
3642
}
3733
3643
 
3734
 
A_STATUS
 
3644
int
3735
3645
wmi_set_host_sleep_mode_cmd(struct wmi_t *wmip,
3736
3646
                              WMI_SET_HOST_SLEEP_MODE_CMD *hostModeCmd)
3737
3647
{
3738
3648
    void    *osbuf;
3739
 
    A_INT8  size;
 
3649
    s8 size;
3740
3650
    WMI_SET_HOST_SLEEP_MODE_CMD *cmd;
3741
 
    A_UINT16 activeTsids=0;
3742
 
    A_UINT8 streamExists=0;
3743
 
    A_UINT8 i;
 
3651
    u16 activeTsids=0;
 
3652
    u8 streamExists=0;
 
3653
    u8 i;
3744
3654
 
3745
3655
    if( hostModeCmd->awake == hostModeCmd->asleep) {
3746
3656
        return A_EINVAL;
3757
3667
 
3758
3668
    cmd = (WMI_SET_HOST_SLEEP_MODE_CMD *)(A_NETBUF_DATA(osbuf));
3759
3669
    A_MEMZERO(cmd, size);
3760
 
    A_MEMCPY(cmd, hostModeCmd, sizeof(WMI_SET_HOST_SLEEP_MODE_CMD));
 
3670
    memcpy(cmd, hostModeCmd, sizeof(WMI_SET_HOST_SLEEP_MODE_CMD));
3761
3671
 
3762
3672
    if(hostModeCmd->asleep) {
3763
3673
        /*
3793
3703
                            NO_SYNC_WMIFLAG));
3794
3704
}
3795
3705
 
3796
 
A_STATUS
 
3706
int
3797
3707
wmi_set_wow_mode_cmd(struct wmi_t *wmip,
3798
3708
                              WMI_SET_WOW_MODE_CMD *wowModeCmd)
3799
3709
{
3800
3710
    void    *osbuf;
3801
 
    A_INT8  size;
 
3711
    s8 size;
3802
3712
    WMI_SET_WOW_MODE_CMD *cmd;
3803
3713
 
3804
3714
    size = sizeof (*cmd);
3812
3722
 
3813
3723
    cmd = (WMI_SET_WOW_MODE_CMD *)(A_NETBUF_DATA(osbuf));
3814
3724
    A_MEMZERO(cmd, size);
3815
 
    A_MEMCPY(cmd, wowModeCmd, sizeof(WMI_SET_WOW_MODE_CMD));
 
3725
    memcpy(cmd, wowModeCmd, sizeof(WMI_SET_WOW_MODE_CMD));
3816
3726
 
3817
3727
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_WOW_MODE_CMDID,
3818
3728
                            NO_SYNC_WMIFLAG));
3819
3729
 
3820
3730
}
3821
3731
 
3822
 
A_STATUS
 
3732
int
3823
3733
wmi_get_wow_list_cmd(struct wmi_t *wmip,
3824
3734
                              WMI_GET_WOW_LIST_CMD *wowListCmd)
3825
3735
{
3826
3736
    void    *osbuf;
3827
 
    A_INT8  size;
 
3737
    s8 size;
3828
3738
    WMI_GET_WOW_LIST_CMD *cmd;
3829
3739
 
3830
3740
    size = sizeof (*cmd);
3838
3748
 
3839
3749
    cmd = (WMI_GET_WOW_LIST_CMD *)(A_NETBUF_DATA(osbuf));
3840
3750
    A_MEMZERO(cmd, size);
3841
 
    A_MEMCPY(cmd, wowListCmd, sizeof(WMI_GET_WOW_LIST_CMD));
 
3751
    memcpy(cmd, wowListCmd, sizeof(WMI_GET_WOW_LIST_CMD));
3842
3752
 
3843
3753
    return (wmi_cmd_send(wmip, osbuf, WMI_GET_WOW_LIST_CMDID,
3844
3754
                            NO_SYNC_WMIFLAG));
3845
3755
 
3846
3756
}
3847
3757
 
3848
 
static A_STATUS
3849
 
wmi_get_wow_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
3758
static int
 
3759
wmi_get_wow_list_event_rx(struct wmi_t *wmip, u8 *datap, int len)
3850
3760
{
3851
3761
    WMI_GET_WOW_LIST_REPLY *reply;
3852
3762
 
3858
3768
    A_WMI_WOW_LIST_EVENT(wmip->wmi_devt, reply->num_filters,
3859
3769
                          reply);
3860
3770
 
3861
 
    return A_OK;
 
3771
    return 0;
3862
3772
}
3863
3773
 
3864
 
A_STATUS wmi_add_wow_pattern_cmd(struct wmi_t *wmip,
 
3774
int wmi_add_wow_pattern_cmd(struct wmi_t *wmip,
3865
3775
                                 WMI_ADD_WOW_PATTERN_CMD *addWowCmd,
3866
 
                                 A_UINT8* pattern, A_UINT8* mask,
3867
 
                                 A_UINT8 pattern_size)
 
3776
                                 u8 *pattern, u8 *mask,
 
3777
                                 u8 pattern_size)
3868
3778
{
3869
3779
    void    *osbuf;
3870
 
    A_INT8  size;
 
3780
    s8 size;
3871
3781
    WMI_ADD_WOW_PATTERN_CMD *cmd;
3872
 
    A_UINT8 *filter_mask = NULL;
 
3782
    u8 *filter_mask = NULL;
3873
3783
 
3874
3784
    size = sizeof (*cmd);
3875
3785
 
3876
 
    size += ((2 * addWowCmd->filter_size)* sizeof(A_UINT8));
 
3786
    size += ((2 * addWowCmd->filter_size)* sizeof(u8));
3877
3787
    osbuf = A_NETBUF_ALLOC(size);
3878
3788
    if (osbuf == NULL) {
3879
3789
        return A_NO_MEMORY;
3886
3796
    cmd->filter_offset = addWowCmd->filter_offset;
3887
3797
    cmd->filter_size = addWowCmd->filter_size;
3888
3798
 
3889
 
    A_MEMCPY(cmd->filter, pattern, addWowCmd->filter_size);
 
3799
    memcpy(cmd->filter, pattern, addWowCmd->filter_size);
3890
3800
 
3891
 
    filter_mask = (A_UINT8*)(cmd->filter + cmd->filter_size);
3892
 
    A_MEMCPY(filter_mask, mask, addWowCmd->filter_size);
 
3801
    filter_mask = (u8 *)(cmd->filter + cmd->filter_size);
 
3802
    memcpy(filter_mask, mask, addWowCmd->filter_size);
3893
3803
 
3894
3804
 
3895
3805
    return (wmi_cmd_send(wmip, osbuf, WMI_ADD_WOW_PATTERN_CMDID,
3896
3806
                            NO_SYNC_WMIFLAG));
3897
3807
}
3898
3808
 
3899
 
A_STATUS
 
3809
int
3900
3810
wmi_del_wow_pattern_cmd(struct wmi_t *wmip,
3901
3811
                              WMI_DEL_WOW_PATTERN_CMD *delWowCmd)
3902
3812
{
3903
3813
    void    *osbuf;
3904
 
    A_INT8  size;
 
3814
    s8 size;
3905
3815
    WMI_DEL_WOW_PATTERN_CMD *cmd;
3906
3816
 
3907
3817
    size = sizeof (*cmd);
3915
3825
 
3916
3826
    cmd = (WMI_DEL_WOW_PATTERN_CMD *)(A_NETBUF_DATA(osbuf));
3917
3827
    A_MEMZERO(cmd, size);
3918
 
    A_MEMCPY(cmd, delWowCmd, sizeof(WMI_DEL_WOW_PATTERN_CMD));
 
3828
    memcpy(cmd, delWowCmd, sizeof(WMI_DEL_WOW_PATTERN_CMD));
3919
3829
 
3920
3830
    return (wmi_cmd_send(wmip, osbuf, WMI_DEL_WOW_PATTERN_CMDID,
3921
3831
                            NO_SYNC_WMIFLAG));
3953
3863
     * event from the target which is used for the configuring the correct
3954
3864
     * thresholds
3955
3865
     */
3956
 
    snrCmd->thresholdAbove1_Val = (A_UINT8)sq_thresh->upper_threshold[0];
3957
 
    snrCmd->thresholdBelow1_Val = (A_UINT8)sq_thresh->lower_threshold[0];
 
3866
    snrCmd->thresholdAbove1_Val = (u8)sq_thresh->upper_threshold[0];
 
3867
    snrCmd->thresholdBelow1_Val = (u8)sq_thresh->lower_threshold[0];
3958
3868
    } else {
3959
3869
        /*
3960
3870
         * In case the user issues multiple times of snr_threshold_setting,
3967
3877
    }
3968
3878
 
3969
3879
}
3970
 
A_STATUS
 
3880
int
3971
3881
wmi_set_snr_threshold_params(struct wmi_t *wmip,
3972
3882
                             WMI_SNR_THRESHOLD_PARAMS_CMD *snrCmd)
3973
3883
{
3984
3894
    return (wmi_send_snr_threshold_params(wmip, snrCmd));
3985
3895
}
3986
3896
 
3987
 
A_STATUS
 
3897
int
3988
3898
wmi_clr_rssi_snr(struct wmi_t *wmip)
3989
3899
{
3990
3900
    void    *osbuf;
3998
3908
                            NO_SYNC_WMIFLAG));
3999
3909
}
4000
3910
 
4001
 
A_STATUS
 
3911
int
4002
3912
wmi_set_lq_threshold_params(struct wmi_t *wmip,
4003
3913
                             WMI_LQ_THRESHOLD_PARAMS_CMD *lqCmd)
4004
3914
{
4005
3915
    void    *osbuf;
4006
 
    A_INT8  size;
 
3916
    s8 size;
4007
3917
    WMI_LQ_THRESHOLD_PARAMS_CMD *cmd;
4008
3918
    /* These values are in ascending order */
4009
3919
    if( lqCmd->thresholdAbove4_Val <= lqCmd->thresholdAbove3_Val ||
4027
3937
 
4028
3938
    cmd = (WMI_LQ_THRESHOLD_PARAMS_CMD *)(A_NETBUF_DATA(osbuf));
4029
3939
    A_MEMZERO(cmd, size);
4030
 
    A_MEMCPY(cmd, lqCmd, sizeof(WMI_LQ_THRESHOLD_PARAMS_CMD));
 
3940
    memcpy(cmd, lqCmd, sizeof(WMI_LQ_THRESHOLD_PARAMS_CMD));
4031
3941
 
4032
3942
    return (wmi_cmd_send(wmip, osbuf, WMI_LQ_THRESHOLD_PARAMS_CMDID,
4033
3943
                            NO_SYNC_WMIFLAG));
4034
3944
}
4035
3945
 
4036
 
A_STATUS
4037
 
wmi_set_error_report_bitmask(struct wmi_t *wmip, A_UINT32 mask)
 
3946
int
 
3947
wmi_set_error_report_bitmask(struct wmi_t *wmip, u32 mask)
4038
3948
{
4039
3949
    void    *osbuf;
4040
 
    A_INT8  size;
 
3950
    s8 size;
4041
3951
    WMI_TARGET_ERROR_REPORT_BITMASK *cmd;
4042
3952
 
4043
3953
    size = sizeof (*cmd);
4058
3968
                            NO_SYNC_WMIFLAG));
4059
3969
}
4060
3970
 
4061
 
A_STATUS
4062
 
wmi_get_challenge_resp_cmd(struct wmi_t *wmip, A_UINT32 cookie, A_UINT32 source)
 
3971
int
 
3972
wmi_get_challenge_resp_cmd(struct wmi_t *wmip, u32 cookie, u32 source)
4063
3973
{
4064
3974
    void *osbuf;
4065
3975
    WMIX_HB_CHALLENGE_RESP_CMD *cmd;
4079
3989
                              NO_SYNC_WMIFLAG));
4080
3990
}
4081
3991
 
4082
 
A_STATUS
4083
 
wmi_config_debug_module_cmd(struct wmi_t *wmip, A_UINT16 mmask,
4084
 
                            A_UINT16 tsr, A_BOOL rep, A_UINT16 size,
4085
 
                            A_UINT32 valid)
 
3992
int
 
3993
wmi_config_debug_module_cmd(struct wmi_t *wmip, u16 mmask,
 
3994
                            u16 tsr, bool rep, u16 size,
 
3995
                            u32 valid)
4086
3996
{
4087
3997
    void *osbuf;
4088
3998
    WMIX_DBGLOG_CFG_MODULE_CMD *cmd;
4105
4015
                              NO_SYNC_WMIFLAG));
4106
4016
}
4107
4017
 
4108
 
A_STATUS
 
4018
int
4109
4019
wmi_get_stats_cmd(struct wmi_t *wmip)
4110
4020
{
4111
4021
    return wmi_simple_cmd(wmip, WMI_GET_STATISTICS_CMDID);
4112
4022
}
4113
4023
 
4114
 
A_STATUS
4115
 
wmi_addBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex, A_UINT8 *bssid)
 
4024
int
 
4025
wmi_addBadAp_cmd(struct wmi_t *wmip, u8 apIndex, u8 *bssid)
4116
4026
{
4117
4027
    void *osbuf;
4118
4028
    WMI_ADD_BAD_AP_CMD *cmd;
4130
4040
 
4131
4041
    cmd = (WMI_ADD_BAD_AP_CMD *)(A_NETBUF_DATA(osbuf));
4132
4042
    cmd->badApIndex = apIndex;
4133
 
    A_MEMCPY(cmd->bssid, bssid, sizeof(cmd->bssid));
 
4043
    memcpy(cmd->bssid, bssid, sizeof(cmd->bssid));
4134
4044
 
4135
4045
    return (wmi_cmd_send(wmip, osbuf, WMI_ADD_BAD_AP_CMDID, SYNC_BEFORE_WMIFLAG));
4136
4046
}
4137
4047
 
4138
 
A_STATUS
4139
 
wmi_deleteBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex)
 
4048
int
 
4049
wmi_deleteBadAp_cmd(struct wmi_t *wmip, u8 apIndex)
4140
4050
{
4141
4051
    void *osbuf;
4142
4052
    WMI_DELETE_BAD_AP_CMD *cmd;
4159
4069
                         NO_SYNC_WMIFLAG));
4160
4070
}
4161
4071
 
4162
 
A_STATUS
 
4072
int
4163
4073
wmi_abort_scan_cmd(struct wmi_t *wmip)
4164
4074
{
4165
4075
    return wmi_simple_cmd(wmip, WMI_ABORT_SCAN_CMDID);
4166
4076
}
4167
4077
 
4168
 
A_STATUS
4169
 
wmi_set_txPwr_cmd(struct wmi_t *wmip, A_UINT8 dbM)
 
4078
int
 
4079
wmi_set_txPwr_cmd(struct wmi_t *wmip, u8 dbM)
4170
4080
{
4171
4081
    void *osbuf;
4172
4082
    WMI_SET_TX_PWR_CMD *cmd;
4184
4094
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_TX_PWR_CMDID, NO_SYNC_WMIFLAG));
4185
4095
}
4186
4096
 
4187
 
A_STATUS
 
4097
int
4188
4098
wmi_get_txPwr_cmd(struct wmi_t *wmip)
4189
4099
{
4190
4100
    return wmi_simple_cmd(wmip, WMI_GET_TX_PWR_CMDID);
4191
4101
}
4192
4102
 
4193
 
A_UINT16
4194
 
wmi_get_mapped_qos_queue(struct wmi_t *wmip, A_UINT8 trafficClass)
 
4103
u16 wmi_get_mapped_qos_queue(struct wmi_t *wmip, u8 trafficClass)
4195
4104
{
4196
 
    A_UINT16 activeTsids=0;
 
4105
    u16 activeTsids=0;
4197
4106
 
4198
4107
    LOCK_WMI(wmip);
4199
4108
    activeTsids = wmip->wmi_streamExistsForAC[trafficClass];
4202
4111
    return activeTsids;
4203
4112
}
4204
4113
 
4205
 
A_STATUS
 
4114
int
4206
4115
wmi_get_roam_tbl_cmd(struct wmi_t *wmip)
4207
4116
{
4208
4117
    return wmi_simple_cmd(wmip, WMI_GET_ROAM_TBL_CMDID);
4209
4118
}
4210
4119
 
4211
 
A_STATUS
4212
 
wmi_get_roam_data_cmd(struct wmi_t *wmip, A_UINT8 roamDataType)
 
4120
int
 
4121
wmi_get_roam_data_cmd(struct wmi_t *wmip, u8 roamDataType)
4213
4122
{
4214
4123
    void *osbuf;
4215
 
    A_UINT32 size = sizeof(A_UINT8);
 
4124
    u32 size = sizeof(u8);
4216
4125
    WMI_TARGET_ROAM_DATA *cmd;
4217
4126
 
4218
4127
    osbuf = A_NETBUF_ALLOC(size);      /* no payload */
4229
4138
                         NO_SYNC_WMIFLAG));
4230
4139
}
4231
4140
 
4232
 
A_STATUS
 
4141
int
4233
4142
wmi_set_roam_ctrl_cmd(struct wmi_t *wmip, WMI_SET_ROAM_CTRL_CMD *p,
4234
 
                      A_UINT8 size)
 
4143
                      u8 size)
4235
4144
{
4236
4145
    void *osbuf;
4237
4146
    WMI_SET_ROAM_CTRL_CMD *cmd;
4246
4155
    cmd = (WMI_SET_ROAM_CTRL_CMD *)(A_NETBUF_DATA(osbuf));
4247
4156
    A_MEMZERO(cmd, size);
4248
4157
 
4249
 
    A_MEMCPY(cmd, p, size);
 
4158
    memcpy(cmd, p, size);
4250
4159
 
4251
4160
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_ROAM_CTRL_CMDID,
4252
4161
                         NO_SYNC_WMIFLAG));
4253
4162
}
4254
4163
 
4255
 
A_STATUS
 
4164
int
4256
4165
wmi_set_powersave_timers_cmd(struct wmi_t *wmip,
4257
4166
                            WMI_POWERSAVE_TIMERS_POLICY_CMD *pCmd,
4258
 
                            A_UINT8 size)
 
4167
                            u8 size)
4259
4168
{
4260
4169
    void *osbuf;
4261
4170
    WMI_POWERSAVE_TIMERS_POLICY_CMD *cmd;
4278
4187
    cmd = (WMI_POWERSAVE_TIMERS_POLICY_CMD *)(A_NETBUF_DATA(osbuf));
4279
4188
    A_MEMZERO(cmd, size);
4280
4189
 
4281
 
    A_MEMCPY(cmd, pCmd, size);
 
4190
    memcpy(cmd, pCmd, size);
4282
4191
 
4283
4192
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_POWERSAVE_TIMERS_POLICY_CMDID,
4284
4193
                         NO_SYNC_WMIFLAG));
4285
4194
}
4286
4195
 
4287
 
#ifdef CONFIG_HOST_GPIO_SUPPORT
4288
 
/* Send a command to Target to change GPIO output pins. */
4289
 
A_STATUS
4290
 
wmi_gpio_output_set(struct wmi_t *wmip,
4291
 
                    A_UINT32 set_mask,
4292
 
                    A_UINT32 clear_mask,
4293
 
                    A_UINT32 enable_mask,
4294
 
                    A_UINT32 disable_mask)
4295
 
{
4296
 
    void *osbuf;
4297
 
    WMIX_GPIO_OUTPUT_SET_CMD *output_set;
4298
 
    int size;
4299
 
 
4300
 
    size = sizeof(*output_set);
4301
 
 
4302
 
    A_DPRINTF(DBG_WMI,
4303
 
        (DBGFMT "Enter - set=0x%x clear=0x%x enb=0x%x dis=0x%x\n", DBGARG,
4304
 
        set_mask, clear_mask, enable_mask, disable_mask));
4305
 
 
4306
 
    osbuf = A_NETBUF_ALLOC(size);
4307
 
    if (osbuf == NULL) {
4308
 
        return A_NO_MEMORY;
4309
 
    }
4310
 
    A_NETBUF_PUT(osbuf, size);
4311
 
    output_set = (WMIX_GPIO_OUTPUT_SET_CMD *)(A_NETBUF_DATA(osbuf));
4312
 
 
4313
 
    output_set->set_mask                   = set_mask;
4314
 
    output_set->clear_mask                 = clear_mask;
4315
 
    output_set->enable_mask                = enable_mask;
4316
 
    output_set->disable_mask               = disable_mask;
4317
 
 
4318
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_OUTPUT_SET_CMDID,
4319
 
                             NO_SYNC_WMIFLAG));
4320
 
}
4321
 
 
4322
 
/* Send a command to the Target requesting state of the GPIO input pins */
4323
 
A_STATUS
4324
 
wmi_gpio_input_get(struct wmi_t *wmip)
4325
 
{
4326
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
4327
 
 
4328
 
    return wmi_simple_cmd_xtnd(wmip, WMIX_GPIO_INPUT_GET_CMDID);
4329
 
}
4330
 
 
4331
 
/* Send a command to the Target that changes the value of a GPIO register. */
4332
 
A_STATUS
4333
 
wmi_gpio_register_set(struct wmi_t *wmip,
4334
 
                      A_UINT32 gpioreg_id,
4335
 
                      A_UINT32 value)
4336
 
{
4337
 
    void *osbuf;
4338
 
    WMIX_GPIO_REGISTER_SET_CMD *register_set;
4339
 
    int size;
4340
 
 
4341
 
    size = sizeof(*register_set);
4342
 
 
4343
 
    A_DPRINTF(DBG_WMI,
4344
 
        (DBGFMT "Enter - reg=%d value=0x%x\n", DBGARG, gpioreg_id, value));
4345
 
 
4346
 
    osbuf = A_NETBUF_ALLOC(size);
4347
 
    if (osbuf == NULL) {
4348
 
        return A_NO_MEMORY;
4349
 
    }
4350
 
    A_NETBUF_PUT(osbuf, size);
4351
 
    register_set = (WMIX_GPIO_REGISTER_SET_CMD *)(A_NETBUF_DATA(osbuf));
4352
 
 
4353
 
    register_set->gpioreg_id               = gpioreg_id;
4354
 
    register_set->value                    = value;
4355
 
 
4356
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_REGISTER_SET_CMDID,
4357
 
                             NO_SYNC_WMIFLAG));
4358
 
}
4359
 
 
4360
 
/* Send a command to the Target to fetch the value of a GPIO register. */
4361
 
A_STATUS
4362
 
wmi_gpio_register_get(struct wmi_t *wmip,
4363
 
                      A_UINT32 gpioreg_id)
4364
 
{
4365
 
    void *osbuf;
4366
 
    WMIX_GPIO_REGISTER_GET_CMD *register_get;
4367
 
    int size;
4368
 
 
4369
 
    size = sizeof(*register_get);
4370
 
 
4371
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter - reg=%d\n", DBGARG, gpioreg_id));
4372
 
 
4373
 
    osbuf = A_NETBUF_ALLOC(size);
4374
 
    if (osbuf == NULL) {
4375
 
        return A_NO_MEMORY;
4376
 
    }
4377
 
    A_NETBUF_PUT(osbuf, size);
4378
 
    register_get = (WMIX_GPIO_REGISTER_GET_CMD *)(A_NETBUF_DATA(osbuf));
4379
 
 
4380
 
    register_get->gpioreg_id               = gpioreg_id;
4381
 
 
4382
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_REGISTER_GET_CMDID,
4383
 
                             NO_SYNC_WMIFLAG));
4384
 
}
4385
 
 
4386
 
/* Send a command to the Target acknowledging some GPIO interrupts. */
4387
 
A_STATUS
4388
 
wmi_gpio_intr_ack(struct wmi_t *wmip,
4389
 
                  A_UINT32 ack_mask)
4390
 
{
4391
 
    void *osbuf;
4392
 
    WMIX_GPIO_INTR_ACK_CMD *intr_ack;
4393
 
    int size;
4394
 
 
4395
 
    size = sizeof(*intr_ack);
4396
 
 
4397
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter ack_mask=0x%x\n", DBGARG, ack_mask));
4398
 
 
4399
 
    osbuf = A_NETBUF_ALLOC(size);
4400
 
    if (osbuf == NULL) {
4401
 
        return A_NO_MEMORY;
4402
 
    }
4403
 
    A_NETBUF_PUT(osbuf, size);
4404
 
    intr_ack = (WMIX_GPIO_INTR_ACK_CMD *)(A_NETBUF_DATA(osbuf));
4405
 
 
4406
 
    intr_ack->ack_mask               = ack_mask;
4407
 
 
4408
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_INTR_ACK_CMDID,
4409
 
                             NO_SYNC_WMIFLAG));
4410
 
}
4411
 
#endif /* CONFIG_HOST_GPIO_SUPPORT */
4412
 
 
4413
 
A_STATUS
4414
 
wmi_set_access_params_cmd(struct wmi_t *wmip, A_UINT8 ac,  A_UINT16 txop, A_UINT8 eCWmin,
4415
 
                          A_UINT8 eCWmax, A_UINT8 aifsn)
 
4196
int
 
4197
wmi_set_access_params_cmd(struct wmi_t *wmip, u8 ac,  u16 txop, u8 eCWmin,
 
4198
                          u8 eCWmax, u8 aifsn)
4416
4199
{
4417
4200
    void *osbuf;
4418
4201
    WMI_SET_ACCESS_PARAMS_CMD *cmd;
4441
4224
                         NO_SYNC_WMIFLAG));
4442
4225
}
4443
4226
 
4444
 
A_STATUS
4445
 
wmi_set_retry_limits_cmd(struct wmi_t *wmip, A_UINT8 frameType,
4446
 
                         A_UINT8 trafficClass, A_UINT8 maxRetries,
4447
 
                         A_UINT8 enableNotify)
 
4227
int
 
4228
wmi_set_retry_limits_cmd(struct wmi_t *wmip, u8 frameType,
 
4229
                         u8 trafficClass, u8 maxRetries,
 
4230
                         u8 enableNotify)
4448
4231
{
4449
4232
    void *osbuf;
4450
4233
    WMI_SET_RETRY_LIMITS_CMD *cmd;
4481
4264
}
4482
4265
 
4483
4266
void
4484
 
wmi_get_current_bssid(struct wmi_t *wmip, A_UINT8 *bssid)
 
4267
wmi_get_current_bssid(struct wmi_t *wmip, u8 *bssid)
4485
4268
{
4486
4269
    if (bssid != NULL) {
4487
 
        A_MEMCPY(bssid, wmip->wmi_bssid, ATH_MAC_LEN);
 
4270
        memcpy(bssid, wmip->wmi_bssid, ATH_MAC_LEN);
4488
4271
    }
4489
4272
}
4490
4273
 
4491
 
A_STATUS
4492
 
wmi_set_opt_mode_cmd(struct wmi_t *wmip, A_UINT8 optMode)
 
4274
int
 
4275
wmi_set_opt_mode_cmd(struct wmi_t *wmip, u8 optMode)
4493
4276
{
4494
4277
    void *osbuf;
4495
4278
    WMI_SET_OPT_MODE_CMD *cmd;
4509
4292
                         SYNC_BOTH_WMIFLAG));
4510
4293
}
4511
4294
 
4512
 
A_STATUS
 
4295
int
4513
4296
wmi_opt_tx_frame_cmd(struct wmi_t *wmip,
4514
 
                      A_UINT8 frmType,
4515
 
                      A_UINT8 *dstMacAddr,
4516
 
                      A_UINT8 *bssid,
4517
 
                      A_UINT16 optIEDataLen,
4518
 
                      A_UINT8 *optIEData)
 
4297
                      u8 frmType,
 
4298
                      u8 *dstMacAddr,
 
4299
                      u8 *bssid,
 
4300
                      u16 optIEDataLen,
 
4301
                      u8 *optIEData)
4519
4302
{
4520
4303
    void *osbuf;
4521
4304
    WMI_OPT_TX_FRAME_CMD *cmd;
4531
4314
 
4532
4315
    cmd->frmType    = frmType;
4533
4316
    cmd->optIEDataLen   = optIEDataLen;
4534
 
    //cmd->optIEData     = (A_UINT8 *)((int)cmd + sizeof(*cmd));
4535
 
    A_MEMCPY(cmd->bssid, bssid, sizeof(cmd->bssid));
4536
 
    A_MEMCPY(cmd->dstAddr, dstMacAddr, sizeof(cmd->dstAddr));
4537
 
    A_MEMCPY(&cmd->optIEData[0], optIEData, optIEDataLen);
 
4317
    //cmd->optIEData     = (u8 *)((int)cmd + sizeof(*cmd));
 
4318
    memcpy(cmd->bssid, bssid, sizeof(cmd->bssid));
 
4319
    memcpy(cmd->dstAddr, dstMacAddr, sizeof(cmd->dstAddr));
 
4320
    memcpy(&cmd->optIEData[0], optIEData, optIEDataLen);
4538
4321
 
4539
4322
    return (wmi_cmd_send(wmip, osbuf, WMI_OPT_TX_FRAME_CMDID,
4540
4323
                         NO_SYNC_WMIFLAG));
4541
4324
}
4542
4325
 
4543
 
A_STATUS
4544
 
wmi_set_adhoc_bconIntvl_cmd(struct wmi_t *wmip, A_UINT16 intvl)
 
4326
int
 
4327
wmi_set_adhoc_bconIntvl_cmd(struct wmi_t *wmip, u16 intvl)
4545
4328
{
4546
4329
    void *osbuf;
4547
4330
    WMI_BEACON_INT_CMD *cmd;
4562
4345
}
4563
4346
 
4564
4347
 
4565
 
A_STATUS
4566
 
wmi_set_voice_pkt_size_cmd(struct wmi_t *wmip, A_UINT16 voicePktSize)
 
4348
int
 
4349
wmi_set_voice_pkt_size_cmd(struct wmi_t *wmip, u16 voicePktSize)
4567
4350
{
4568
4351
    void *osbuf;
4569
4352
    WMI_SET_VOICE_PKT_SIZE_CMD *cmd;
4584
4367
}
4585
4368
 
4586
4369
 
4587
 
A_STATUS
4588
 
wmi_set_max_sp_len_cmd(struct wmi_t *wmip, A_UINT8 maxSPLen)
 
4370
int
 
4371
wmi_set_max_sp_len_cmd(struct wmi_t *wmip, u8 maxSPLen)
4589
4372
{
4590
4373
    void *osbuf;
4591
4374
    WMI_SET_MAX_SP_LEN_CMD *cmd;
4611
4394
            NO_SYNC_WMIFLAG));
4612
4395
}
4613
4396
 
4614
 
A_UINT8
4615
 
wmi_determine_userPriority(
4616
 
    A_UINT8 *pkt,
4617
 
    A_UINT32 layer2Pri)
 
4397
u8 wmi_determine_userPriority(
 
4398
    u8 *pkt,
 
4399
    u32 layer2Pri)
4618
4400
{
4619
 
    A_UINT8 ipPri;
 
4401
    u8 ipPri;
4620
4402
    iphdr *ipHdr = (iphdr *)pkt;
4621
4403
 
4622
4404
    /* Determine IPTOS priority */
4632
4414
    ipPri &= 0x7;
4633
4415
 
4634
4416
    if ((layer2Pri & 0x7) > ipPri)
4635
 
        return ((A_UINT8)layer2Pri & 0x7);
 
4417
        return ((u8)layer2Pri & 0x7);
4636
4418
    else
4637
4419
        return ipPri;
4638
4420
}
4639
4421
 
4640
 
A_UINT8
4641
 
convert_userPriority_to_trafficClass(A_UINT8 userPriority)
 
4422
u8 convert_userPriority_to_trafficClass(u8 userPriority)
4642
4423
{
4643
4424
    return  (up_to_ac[userPriority & 0x7]);
4644
4425
}
4645
4426
 
4646
 
A_UINT8
4647
 
wmi_get_power_mode_cmd(struct wmi_t *wmip)
 
4427
u8 wmi_get_power_mode_cmd(struct wmi_t *wmip)
4648
4428
{
4649
4429
    return wmip->wmi_powerMode;
4650
4430
}
4651
4431
 
4652
 
A_STATUS
4653
 
wmi_verify_tspec_params(WMI_CREATE_PSTREAM_CMD *pCmd, A_BOOL tspecCompliance)
 
4432
int
 
4433
wmi_verify_tspec_params(WMI_CREATE_PSTREAM_CMD *pCmd, int tspecCompliance)
4654
4434
{
4655
 
    A_STATUS ret = A_OK;
 
4435
    int ret = 0;
4656
4436
 
4657
4437
#define TSPEC_SUSPENSION_INTERVAL_ATHEROS_DEF (~0)
4658
4438
#define TSPEC_SERVICE_START_TIME_ATHEROS_DEF  0
4682
4462
}
4683
4463
 
4684
4464
#ifdef CONFIG_HOST_TCMD_SUPPORT
4685
 
static A_STATUS
4686
 
wmi_tcmd_test_report_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
4465
static int
 
4466
wmi_tcmd_test_report_rx(struct wmi_t *wmip, u8 *datap, int len)
4687
4467
{
4688
4468
 
4689
4469
   A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
4690
4470
 
4691
 
   A_WMI_TCMD_RX_REPORT_EVENT(wmip->wmi_devt, datap, len);
4692
 
 
4693
 
   return A_OK;
 
4471
   return 0;
4694
4472
}
4695
4473
 
4696
4474
#endif /* CONFIG_HOST_TCMD_SUPPORT*/
4697
4475
 
4698
 
A_STATUS
4699
 
wmi_set_authmode_cmd(struct wmi_t *wmip, A_UINT8 mode)
 
4476
int
 
4477
wmi_set_authmode_cmd(struct wmi_t *wmip, u8 mode)
4700
4478
{
4701
4479
    void *osbuf;
4702
4480
    WMI_SET_AUTH_MODE_CMD *cmd;
4716
4494
            NO_SYNC_WMIFLAG));
4717
4495
}
4718
4496
 
4719
 
A_STATUS
4720
 
wmi_set_reassocmode_cmd(struct wmi_t *wmip, A_UINT8 mode)
 
4497
int
 
4498
wmi_set_reassocmode_cmd(struct wmi_t *wmip, u8 mode)
4721
4499
{
4722
4500
    void *osbuf;
4723
4501
    WMI_SET_REASSOC_MODE_CMD *cmd;
4737
4515
            NO_SYNC_WMIFLAG));
4738
4516
}
4739
4517
 
4740
 
A_STATUS
4741
 
wmi_set_lpreamble_cmd(struct wmi_t *wmip, A_UINT8 status, A_UINT8 preamblePolicy)
 
4518
int
 
4519
wmi_set_lpreamble_cmd(struct wmi_t *wmip, u8 status, u8 preamblePolicy)
4742
4520
{
4743
4521
    void *osbuf;
4744
4522
    WMI_SET_LPREAMBLE_CMD *cmd;
4759
4537
            NO_SYNC_WMIFLAG));
4760
4538
}
4761
4539
 
4762
 
A_STATUS
4763
 
wmi_set_rts_cmd(struct wmi_t *wmip, A_UINT16 threshold)
 
4540
int
 
4541
wmi_set_rts_cmd(struct wmi_t *wmip, u16 threshold)
4764
4542
{
4765
4543
    void *osbuf;
4766
4544
    WMI_SET_RTS_CMD *cmd;
4780
4558
            NO_SYNC_WMIFLAG));
4781
4559
}
4782
4560
 
4783
 
A_STATUS
 
4561
int
4784
4562
wmi_set_wmm_cmd(struct wmi_t *wmip, WMI_WMM_STATUS status)
4785
4563
{
4786
4564
    void *osbuf;
4802
4580
 
4803
4581
}
4804
4582
 
4805
 
A_STATUS
4806
 
wmi_set_qos_supp_cmd(struct wmi_t *wmip, A_UINT8 status)
 
4583
int
 
4584
wmi_set_qos_supp_cmd(struct wmi_t *wmip, u8 status)
4807
4585
{
4808
4586
    void *osbuf;
4809
4587
    WMI_SET_QOS_SUPP_CMD *cmd;
4823
4601
}
4824
4602
 
4825
4603
 
4826
 
A_STATUS
 
4604
int
4827
4605
wmi_set_wmm_txop(struct wmi_t *wmip, WMI_TXOP_CFG cfg)
4828
4606
{
4829
4607
    void *osbuf;
4848
4626
 
4849
4627
}
4850
4628
 
4851
 
A_STATUS
4852
 
wmi_set_country(struct wmi_t *wmip, A_UCHAR *countryCode)
 
4629
int
 
4630
wmi_set_country(struct wmi_t *wmip, u8 *countryCode)
4853
4631
{
4854
4632
    void *osbuf;
4855
4633
    WMI_AP_SET_COUNTRY_CMD *cmd;
4863
4641
 
4864
4642
    cmd = (WMI_AP_SET_COUNTRY_CMD *)(A_NETBUF_DATA(osbuf));
4865
4643
    A_MEMZERO(cmd, sizeof(*cmd));
4866
 
    A_MEMCPY(cmd->countryCode,countryCode,3);
 
4644
    memcpy(cmd->countryCode,countryCode,3);
4867
4645
 
4868
4646
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_SET_COUNTRY_CMDID,
4869
4647
            NO_SYNC_WMIFLAG));
4872
4650
#ifdef CONFIG_HOST_TCMD_SUPPORT
4873
4651
/* WMI  layer doesn't need to know the data type of the test cmd.
4874
4652
   This would be beneficial for customers like Qualcomm, who might
4875
 
   have different test command requirements from differnt manufacturers
 
4653
   have different test command requirements from different manufacturers
4876
4654
 */
4877
 
A_STATUS
4878
 
wmi_test_cmd(struct wmi_t *wmip, A_UINT8 *buf, A_UINT32  len)
 
4655
int
 
4656
wmi_test_cmd(struct wmi_t *wmip, u8 *buf, u32 len)
4879
4657
{
4880
4658
    void *osbuf;
4881
4659
    char *data;
4889
4667
    }
4890
4668
    A_NETBUF_PUT(osbuf, len);
4891
4669
    data = A_NETBUF_DATA(osbuf);
4892
 
    A_MEMCPY(data, buf, len);
 
4670
    memcpy(data, buf, len);
4893
4671
 
4894
4672
    return(wmi_cmd_send(wmip, osbuf, WMI_TEST_CMDID,
4895
4673
         NO_SYNC_WMIFLAG));
4897
4675
 
4898
4676
#endif
4899
4677
 
4900
 
A_STATUS
4901
 
wmi_set_bt_status_cmd(struct wmi_t *wmip, A_UINT8 streamType, A_UINT8 status)
 
4678
int
 
4679
wmi_set_bt_status_cmd(struct wmi_t *wmip, u8 streamType, u8 status)
4902
4680
{
4903
4681
    void *osbuf;
4904
4682
    WMI_SET_BT_STATUS_CMD *cmd;
4921
4699
            NO_SYNC_WMIFLAG));
4922
4700
}
4923
4701
 
4924
 
A_STATUS
 
4702
int
4925
4703
wmi_set_bt_params_cmd(struct wmi_t *wmip, WMI_SET_BT_PARAMS_CMD* cmd)
4926
4704
{
4927
4705
    void *osbuf;
4977
4755
 
4978
4756
    alloc_cmd = (WMI_SET_BT_PARAMS_CMD *)(A_NETBUF_DATA(osbuf));
4979
4757
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
4980
 
    A_MEMCPY(alloc_cmd, cmd, sizeof(*cmd));
 
4758
    memcpy(alloc_cmd, cmd, sizeof(*cmd));
4981
4759
 
4982
4760
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BT_PARAMS_CMDID,
4983
4761
            NO_SYNC_WMIFLAG));
4984
4762
}
4985
4763
 
4986
 
A_STATUS
 
4764
int
4987
4765
wmi_set_btcoex_fe_ant_cmd(struct wmi_t *wmip, WMI_SET_BTCOEX_FE_ANT_CMD * cmd)
4988
4766
{
4989
4767
        void *osbuf;
4996
4774
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
4997
4775
    alloc_cmd = (WMI_SET_BTCOEX_FE_ANT_CMD *)(A_NETBUF_DATA(osbuf));
4998
4776
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
4999
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_FE_ANT_CMD));
 
4777
        memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_FE_ANT_CMD));
5000
4778
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_FE_ANT_CMDID,
5001
4779
                         NO_SYNC_WMIFLAG));
5002
4780
 
5003
4781
}
5004
4782
 
5005
4783
 
5006
 
A_STATUS
 
4784
int
5007
4785
wmi_set_btcoex_colocated_bt_dev_cmd(struct wmi_t *wmip,
5008
4786
                                                WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD * cmd)
5009
4787
{
5017
4795
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
5018
4796
    alloc_cmd = (WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD *)(A_NETBUF_DATA(osbuf));
5019
4797
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
5020
 
    A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD));
 
4798
    memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD));
5021
4799
    A_PRINTF("colocated bt = %d\n", alloc_cmd->btcoexCoLocatedBTdev);
5022
4800
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMDID,
5023
4801
                         NO_SYNC_WMIFLAG));
5024
4802
 
5025
4803
}
5026
4804
 
5027
 
A_STATUS
 
4805
int
5028
4806
wmi_set_btcoex_btinquiry_page_config_cmd(struct wmi_t *wmip,
5029
4807
                                                WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD* cmd)
5030
4808
{
5038
4816
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
5039
4817
    alloc_cmd = (WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD *)(A_NETBUF_DATA(osbuf));
5040
4818
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
5041
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD));
 
4819
        memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD));
5042
4820
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMDID,
5043
4821
                         NO_SYNC_WMIFLAG));
5044
4822
 
5045
4823
}
5046
4824
 
5047
 
A_STATUS
 
4825
int
5048
4826
wmi_set_btcoex_sco_config_cmd(struct wmi_t *wmip,
5049
4827
                                                WMI_SET_BTCOEX_SCO_CONFIG_CMD * cmd)
5050
4828
{
5058
4836
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
5059
4837
    alloc_cmd = (WMI_SET_BTCOEX_SCO_CONFIG_CMD *)(A_NETBUF_DATA(osbuf));
5060
4838
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
5061
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_SCO_CONFIG_CMD));
 
4839
        memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_SCO_CONFIG_CMD));
5062
4840
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_SCO_CONFIG_CMDID ,
5063
4841
                         NO_SYNC_WMIFLAG));
5064
4842
 
5065
4843
}
5066
4844
 
5067
 
A_STATUS
 
4845
int
5068
4846
wmi_set_btcoex_a2dp_config_cmd(struct wmi_t *wmip,
5069
4847
                                                WMI_SET_BTCOEX_A2DP_CONFIG_CMD * cmd)
5070
4848
{
5078
4856
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
5079
4857
    alloc_cmd = (WMI_SET_BTCOEX_A2DP_CONFIG_CMD *)(A_NETBUF_DATA(osbuf));
5080
4858
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
5081
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_A2DP_CONFIG_CMD));
 
4859
        memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_A2DP_CONFIG_CMD));
5082
4860
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_A2DP_CONFIG_CMDID ,
5083
4861
                         NO_SYNC_WMIFLAG));
5084
4862
 
5085
4863
}
5086
4864
 
5087
 
A_STATUS
 
4865
int
5088
4866
wmi_set_btcoex_aclcoex_config_cmd(struct wmi_t *wmip,
5089
4867
                                                WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD * cmd)
5090
4868
{
5098
4876
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
5099
4877
    alloc_cmd = (WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD *)(A_NETBUF_DATA(osbuf));
5100
4878
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
5101
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD));
 
4879
        memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD));
5102
4880
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMDID ,
5103
4881
                         NO_SYNC_WMIFLAG));
5104
4882
 
5105
4883
}
5106
4884
 
5107
 
A_STATUS
 
4885
int
5108
4886
wmi_set_btcoex_debug_cmd(struct wmi_t *wmip, WMI_SET_BTCOEX_DEBUG_CMD * cmd)
5109
4887
{
5110
4888
        void *osbuf;
5117
4895
        A_NETBUF_PUT(osbuf, sizeof(*cmd));
5118
4896
        alloc_cmd = (WMI_SET_BTCOEX_DEBUG_CMD *)(A_NETBUF_DATA(osbuf));
5119
4897
        A_MEMZERO(alloc_cmd, sizeof(*cmd));
5120
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_DEBUG_CMD));
 
4898
        memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_DEBUG_CMD));
5121
4899
        return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_DEBUG_CMDID ,
5122
4900
                                                         NO_SYNC_WMIFLAG));
5123
4901
 
5124
4902
}
5125
4903
 
5126
 
A_STATUS
 
4904
int
5127
4905
wmi_set_btcoex_bt_operating_status_cmd(struct wmi_t * wmip,
5128
4906
                                        WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD * cmd)
5129
4907
{
5137
4915
        A_NETBUF_PUT(osbuf, sizeof(*cmd));
5138
4916
        alloc_cmd = (WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD *)(A_NETBUF_DATA(osbuf));
5139
4917
        A_MEMZERO(alloc_cmd, sizeof(*cmd));
5140
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD));
 
4918
        memcpy(alloc_cmd,cmd,sizeof(WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD));
5141
4919
        return (wmi_cmd_send(wmip, osbuf, WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMDID ,
5142
4920
                                                                 NO_SYNC_WMIFLAG));
5143
4921
 
5144
4922
}
5145
4923
 
5146
 
A_STATUS
 
4924
int
5147
4925
wmi_get_btcoex_config_cmd(struct wmi_t * wmip, WMI_GET_BTCOEX_CONFIG_CMD * cmd)
5148
4926
{
5149
4927
        void *osbuf;
5156
4934
        A_NETBUF_PUT(osbuf, sizeof(*cmd));
5157
4935
        alloc_cmd = (WMI_GET_BTCOEX_CONFIG_CMD *)(A_NETBUF_DATA(osbuf));
5158
4936
        A_MEMZERO(alloc_cmd, sizeof(*cmd));
5159
 
        A_MEMCPY(alloc_cmd,cmd,sizeof(WMI_GET_BTCOEX_CONFIG_CMD));
 
4937
        memcpy(alloc_cmd,cmd,sizeof(WMI_GET_BTCOEX_CONFIG_CMD));
5160
4938
        return (wmi_cmd_send(wmip, osbuf, WMI_GET_BTCOEX_CONFIG_CMDID ,
5161
4939
                                                         NO_SYNC_WMIFLAG));
5162
4940
 
5163
4941
}
5164
4942
 
5165
 
A_STATUS
 
4943
int
5166
4944
wmi_get_btcoex_stats_cmd(struct wmi_t *wmip)
5167
4945
{
5168
4946
 
5170
4948
 
5171
4949
}
5172
4950
 
5173
 
A_STATUS
 
4951
int
5174
4952
wmi_get_keepalive_configured(struct wmi_t *wmip)
5175
4953
{
5176
4954
    void *osbuf;
5186
4964
                         NO_SYNC_WMIFLAG));
5187
4965
}
5188
4966
 
5189
 
A_UINT8
5190
 
wmi_get_keepalive_cmd(struct wmi_t *wmip)
 
4967
u8 wmi_get_keepalive_cmd(struct wmi_t *wmip)
5191
4968
{
5192
4969
    return wmip->wmi_keepaliveInterval;
5193
4970
}
5194
4971
 
5195
 
A_STATUS
5196
 
wmi_set_keepalive_cmd(struct wmi_t *wmip, A_UINT8 keepaliveInterval)
 
4972
int
 
4973
wmi_set_keepalive_cmd(struct wmi_t *wmip, u8 keepaliveInterval)
5197
4974
{
5198
4975
    void *osbuf;
5199
4976
    WMI_SET_KEEPALIVE_CMD *cmd;
5214
4991
                         NO_SYNC_WMIFLAG));
5215
4992
}
5216
4993
 
5217
 
A_STATUS
5218
 
wmi_set_params_cmd(struct wmi_t *wmip, A_UINT32 opcode, A_UINT32 length, A_CHAR* buffer)
 
4994
int
 
4995
wmi_set_params_cmd(struct wmi_t *wmip, u32 opcode, u32 length, char *buffer)
5219
4996
{
5220
4997
    void *osbuf;
5221
4998
    WMI_SET_PARAMS_CMD *cmd;
5231
5008
    A_MEMZERO(cmd, sizeof(*cmd));
5232
5009
    cmd->opcode = opcode;
5233
5010
    cmd->length = length;
5234
 
    A_MEMCPY(cmd->buffer, buffer, length);
 
5011
    memcpy(cmd->buffer, buffer, length);
5235
5012
 
5236
5013
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_PARAMS_CMDID,
5237
5014
                         NO_SYNC_WMIFLAG));
5238
5015
}
5239
5016
 
5240
5017
 
5241
 
A_STATUS
5242
 
wmi_set_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 dot1, A_UINT8 dot2, A_UINT8 dot3, A_UINT8 dot4)
 
5018
int
 
5019
wmi_set_mcast_filter_cmd(struct wmi_t *wmip, u8 dot1, u8 dot2, u8 dot3, u8 dot4)
5243
5020
{
5244
5021
    void *osbuf;
5245
5022
    WMI_SET_MCAST_FILTER_CMD *cmd;
5264
5041
}
5265
5042
 
5266
5043
 
5267
 
A_STATUS
5268
 
wmi_del_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 dot1, A_UINT8 dot2, A_UINT8 dot3, A_UINT8 dot4)
 
5044
int
 
5045
wmi_del_mcast_filter_cmd(struct wmi_t *wmip, u8 dot1, u8 dot2, u8 dot3, u8 dot4)
5269
5046
{
5270
5047
    void *osbuf;
5271
5048
    WMI_SET_MCAST_FILTER_CMD *cmd;
5289
5066
                         NO_SYNC_WMIFLAG));
5290
5067
}
5291
5068
 
5292
 
A_STATUS
5293
 
wmi_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 enable)
 
5069
int
 
5070
wmi_mcast_filter_cmd(struct wmi_t *wmip, u8 enable)
5294
5071
{
5295
5072
    void *osbuf;
5296
5073
    WMI_MCAST_FILTER_CMD *cmd;
5309
5086
                         NO_SYNC_WMIFLAG));
5310
5087
}
5311
5088
 
5312
 
A_STATUS
5313
 
wmi_set_appie_cmd(struct wmi_t *wmip, A_UINT8 mgmtFrmType, A_UINT8 ieLen,
5314
 
                  A_UINT8 *ieInfo)
 
5089
int
 
5090
wmi_set_appie_cmd(struct wmi_t *wmip, u8 mgmtFrmType, u8 ieLen,
 
5091
                  u8 *ieInfo)
5315
5092
{
5316
5093
    void *osbuf;
5317
5094
    WMI_SET_APPIE_CMD *cmd;
5318
 
    A_UINT16 cmdLen;
 
5095
    u16 cmdLen;
5319
5096
 
5320
5097
    cmdLen = sizeof(*cmd) + ieLen - 1;
5321
5098
    osbuf = A_NETBUF_ALLOC(cmdLen);
5330
5107
 
5331
5108
    cmd->mgmtFrmType = mgmtFrmType;
5332
5109
    cmd->ieLen = ieLen;
5333
 
    A_MEMCPY(cmd->ieInfo, ieInfo, ieLen);
 
5110
    memcpy(cmd->ieInfo, ieInfo, ieLen);
5334
5111
 
5335
5112
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_APPIE_CMDID, NO_SYNC_WMIFLAG));
5336
5113
}
5337
5114
 
5338
 
A_STATUS
5339
 
wmi_set_halparam_cmd(struct wmi_t *wmip, A_UINT8 *cmd, A_UINT16 dataLen)
 
5115
int
 
5116
wmi_set_halparam_cmd(struct wmi_t *wmip, u8 *cmd, u16 dataLen)
5340
5117
{
5341
5118
    void *osbuf;
5342
 
    A_UINT8 *data;
 
5119
    u8 *data;
5343
5120
 
5344
5121
    osbuf = A_NETBUF_ALLOC(dataLen);
5345
5122
    if (osbuf == NULL) {
5350
5127
 
5351
5128
    data = A_NETBUF_DATA(osbuf);
5352
5129
 
5353
 
    A_MEMCPY(data, cmd, dataLen);
 
5130
    memcpy(data, cmd, dataLen);
5354
5131
 
5355
5132
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_WHALPARAM_CMDID, NO_SYNC_WMIFLAG));
5356
5133
}
5357
5134
 
5358
 
A_INT32
5359
 
wmi_get_rate(A_INT8 rateindex)
 
5135
s32 wmi_get_rate(s8 rateindex)
5360
5136
{
5361
5137
    if (rateindex == RATE_AUTO) {
5362
5138
        return 0;
5363
5139
    } else {
5364
 
        return(wmi_rateTable[(A_UINT32) rateindex][0]);
 
5140
        return(wmi_rateTable[(u32) rateindex][0]);
5365
5141
    }
5366
5142
}
5367
5143
 
5375
5151
}
5376
5152
 
5377
5153
void
5378
 
wmi_set_nodeage(struct wmi_t *wmip, A_UINT32 nodeAge)
 
5154
wmi_set_nodeage(struct wmi_t *wmip, u32 nodeAge)
5379
5155
{
5380
5156
    wlan_set_nodeage(&wmip->wmi_scan_table,nodeAge);
5381
5157
}
5382
5158
 
5383
5159
bss_t *
5384
 
wmi_find_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
5385
 
                   A_UINT32 ssidLength, A_BOOL bIsWPA2, A_BOOL bMatchSSID)
 
5160
wmi_find_Ssidnode (struct wmi_t *wmip, u8 *pSsid,
 
5161
                   u32 ssidLength, bool bIsWPA2, bool bMatchSSID)
5386
5162
{
5387
5163
    bss_t *node = NULL;
5388
5164
    node = wlan_find_Ssidnode (&wmip->wmi_scan_table, pSsid,
5406
5182
}
5407
5183
 
5408
5184
bss_t *
5409
 
wmi_find_node(struct wmi_t *wmip, const A_UINT8 *macaddr)
 
5185
wmi_find_node(struct wmi_t *wmip, const u8 *macaddr)
5410
5186
{
5411
5187
    bss_t *ni=NULL;
5412
5188
    ni=wlan_find_node(&wmip->wmi_scan_table,macaddr);
5414
5190
}
5415
5191
 
5416
5192
void
5417
 
wmi_free_node(struct wmi_t *wmip, const A_UINT8 *macaddr)
 
5193
wmi_free_node(struct wmi_t *wmip, const u8 *macaddr)
5418
5194
{
5419
5195
    bss_t *ni=NULL;
5420
5196
 
5426
5202
    return;
5427
5203
}
5428
5204
 
5429
 
A_STATUS
 
5205
int
5430
5206
wmi_dset_open_reply(struct wmi_t *wmip,
5431
 
                    A_UINT32 status,
5432
 
                    A_UINT32 access_cookie,
5433
 
                    A_UINT32 dset_size,
5434
 
                    A_UINT32 dset_version,
5435
 
                    A_UINT32 targ_handle,
5436
 
                    A_UINT32 targ_reply_fn,
5437
 
                    A_UINT32 targ_reply_arg)
 
5207
                    u32 status,
 
5208
                    u32 access_cookie,
 
5209
                    u32 dset_size,
 
5210
                    u32 dset_version,
 
5211
                    u32 targ_handle,
 
5212
                    u32 targ_reply_fn,
 
5213
                    u32 targ_reply_arg)
5438
5214
{
5439
5215
    void *osbuf;
5440
5216
    WMIX_DSETOPEN_REPLY_CMD *open_reply;
5461
5237
                             NO_SYNC_WMIFLAG));
5462
5238
}
5463
5239
 
5464
 
static A_STATUS
5465
 
wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len)
 
5240
static int
 
5241
wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, u8 *datap, u32 len)
5466
5242
{
5467
5243
    WMI_PMKID_LIST_REPLY *reply;
5468
 
    A_UINT32 expected_len;
 
5244
    u32 expected_len;
5469
5245
 
5470
5246
    if (len < sizeof(WMI_PMKID_LIST_REPLY)) {
5471
5247
        return A_EINVAL;
5480
5256
    A_WMI_PMKID_LIST_EVENT(wmip->wmi_devt, reply->numPMKID,
5481
5257
                           reply->pmkidList, reply->bssidList[0]);
5482
5258
 
5483
 
    return A_OK;
 
5259
    return 0;
5484
5260
}
5485
5261
 
5486
5262
 
5487
 
static A_STATUS
5488
 
wmi_set_params_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len)
 
5263
static int
 
5264
wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, u32 len)
5489
5265
{
5490
5266
    WMI_SET_PARAMS_REPLY *reply;
5491
5267
 
5494
5270
    }
5495
5271
    reply = (WMI_SET_PARAMS_REPLY *)datap;
5496
5272
 
5497
 
    if (A_OK == reply->status)
 
5273
    if (0 == reply->status)
5498
5274
    {
5499
5275
 
5500
5276
    }
5503
5279
 
5504
5280
    }
5505
5281
 
5506
 
    return A_OK;
5507
 
}
5508
 
 
5509
 
 
5510
 
 
5511
 
static A_STATUS
5512
 
wmi_acm_reject_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len)
5513
 
{
5514
 
    WMI_ACM_REJECT_EVENT *ev;
5515
 
 
5516
 
    ev = (WMI_ACM_REJECT_EVENT *)datap;
5517
 
    wmip->wmi_traffic_class = ev->trafficClass;
5518
 
    printk("ACM REJECT %d\n",wmip->wmi_traffic_class);
5519
 
    return A_OK;
 
5282
    return 0;
5520
5283
}
5521
5284
 
5522
5285
 
5523
5286
#ifdef CONFIG_HOST_DSET_SUPPORT
5524
 
A_STATUS
 
5287
int
5525
5288
wmi_dset_data_reply(struct wmi_t *wmip,
5526
 
                    A_UINT32 status,
5527
 
                    A_UINT8 *user_buf,
5528
 
                    A_UINT32 length,
5529
 
                    A_UINT32 targ_buf,
5530
 
                    A_UINT32 targ_reply_fn,
5531
 
                    A_UINT32 targ_reply_arg)
 
5289
                    u32 status,
 
5290
                    u8 *user_buf,
 
5291
                    u32 length,
 
5292
                    u32 targ_buf,
 
5293
                    u32 targ_reply_fn,
 
5294
                    u32 targ_reply_arg)
5532
5295
{
5533
5296
    void *osbuf;
5534
5297
    WMIX_DSETDATA_REPLY_CMD *data_reply;
5535
 
    A_UINT32 size;
 
5298
    u32 size;
5536
5299
 
5537
5300
    size = sizeof(*data_reply) + length;
5538
5301
 
5556
5319
    data_reply->targ_reply_arg             = targ_reply_arg;
5557
5320
    data_reply->length                     = length;
5558
5321
 
5559
 
    if (status == A_OK) {
 
5322
    if (status == 0) {
5560
5323
        if (a_copy_from_user(data_reply->buf, user_buf, length)) {
5561
5324
            A_NETBUF_FREE(osbuf);
5562
5325
            return A_ERROR;
5568
5331
}
5569
5332
#endif /* CONFIG_HOST_DSET_SUPPORT */
5570
5333
 
5571
 
A_STATUS
5572
 
wmi_set_wsc_status_cmd(struct wmi_t *wmip, A_UINT32 status)
 
5334
int
 
5335
wmi_set_wsc_status_cmd(struct wmi_t *wmip, u32 status)
5573
5336
{
5574
5337
    void *osbuf;
5575
5338
    char *cmd;
5592
5355
}
5593
5356
 
5594
5357
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
5595
 
A_STATUS
 
5358
int
5596
5359
wmi_prof_cfg_cmd(struct wmi_t *wmip,
5597
 
                 A_UINT32 period,
5598
 
                 A_UINT32 nbins)
 
5360
                 u32 period,
 
5361
                 u32 nbins)
5599
5362
{
5600
5363
    void *osbuf;
5601
5364
    WMIX_PROF_CFG_CMD *cmd;
5615
5378
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_PROF_CFG_CMDID, NO_SYNC_WMIFLAG));
5616
5379
}
5617
5380
 
5618
 
A_STATUS
5619
 
wmi_prof_addr_set_cmd(struct wmi_t *wmip, A_UINT32 addr)
 
5381
int
 
5382
wmi_prof_addr_set_cmd(struct wmi_t *wmip, u32 addr)
5620
5383
{
5621
5384
    void *osbuf;
5622
5385
    WMIX_PROF_ADDR_SET_CMD *cmd;
5635
5398
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_PROF_ADDR_SET_CMDID, NO_SYNC_WMIFLAG));
5636
5399
}
5637
5400
 
5638
 
A_STATUS
 
5401
int
5639
5402
wmi_prof_start_cmd(struct wmi_t *wmip)
5640
5403
{
5641
5404
    return wmi_simple_cmd_xtnd(wmip, WMIX_PROF_START_CMDID);
5642
5405
}
5643
5406
 
5644
 
A_STATUS
 
5407
int
5645
5408
wmi_prof_stop_cmd(struct wmi_t *wmip)
5646
5409
{
5647
5410
    return wmi_simple_cmd_xtnd(wmip, WMIX_PROF_STOP_CMDID);
5648
5411
}
5649
5412
 
5650
 
A_STATUS
 
5413
int
5651
5414
wmi_prof_count_get_cmd(struct wmi_t *wmip)
5652
5415
{
5653
5416
    return wmi_simple_cmd_xtnd(wmip, WMIX_PROF_COUNT_GET_CMDID);
5654
5417
}
5655
5418
 
5656
5419
/* Called to handle WMIX_PROF_CONT_EVENTID */
5657
 
static A_STATUS
5658
 
wmi_prof_count_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
5420
static int
 
5421
wmi_prof_count_rx(struct wmi_t *wmip, u8 *datap, int len)
5659
5422
{
5660
5423
    WMIX_PROF_COUNT_EVENT *prof_data = (WMIX_PROF_COUNT_EVENT *)datap;
5661
5424
 
5665
5428
 
5666
5429
    A_WMI_PROF_COUNT_RX(prof_data->addr, prof_data->count);
5667
5430
 
5668
 
    return A_OK;
 
5431
    return 0;
5669
5432
}
5670
5433
#endif /* CONFIG_TARGET_PROFILE_SUPPORT */
5671
5434
 
5677
5440
wmi_scan_indication (struct wmi_t *wmip)
5678
5441
{
5679
5442
    struct ieee80211_node_table *nt;
5680
 
    A_UINT32 gen;
5681
 
    A_UINT32 size;
5682
 
    A_UINT32 bsssize;
 
5443
    u32 gen;
 
5444
    u32 size;
 
5445
    u32 bsssize;
5683
5446
    bss_t *bss;
5684
 
    A_UINT32 numbss;
 
5447
    u32 numbss;
5685
5448
    PNDIS_802_11_BSSID_SCAN_INFO psi;
5686
5449
    PBYTE  pie;
5687
5450
    NDIS_802_11_FIXED_IEs *pFixed;
5688
5451
    NDIS_802_11_VARIABLE_IEs *pVar;
5689
 
    A_UINT32  RateSize;
 
5452
    u32 RateSize;
5690
5453
 
5691
5454
    struct ar6kScanIndication
5692
5455
    {
5884
5647
 
5885
5648
    ar6000_scan_indication (wmip->wmi_devt, pAr6kScanIndEvent, size);
5886
5649
 
5887
 
    A_FREE(pAr6kScanIndEvent);
 
5650
    kfree(pAr6kScanIndEvent);
5888
5651
}
5889
5652
#endif
5890
5653
 
5891
 
A_UINT8
5892
 
ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
5893
 
                           A_UINT32 size)
 
5654
u8 ar6000_get_upper_threshold(s16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
 
5655
                           u32 size)
5894
5656
{
5895
 
    A_UINT32 index;
5896
 
    A_UINT8 threshold = (A_UINT8)sq_thresh->upper_threshold[size - 1];
 
5657
    u32 index;
 
5658
    u8 threshold = (u8)sq_thresh->upper_threshold[size - 1];
5897
5659
 
5898
5660
    /* The list is already in sorted order. Get the next lower value */
5899
5661
    for (index = 0; index < size; index ++) {
5900
5662
        if (rssi < sq_thresh->upper_threshold[index]) {
5901
 
            threshold = (A_UINT8)sq_thresh->upper_threshold[index];
 
5663
            threshold = (u8)sq_thresh->upper_threshold[index];
5902
5664
            break;
5903
5665
        }
5904
5666
    }
5906
5668
    return threshold;
5907
5669
}
5908
5670
 
5909
 
A_UINT8
5910
 
ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
5911
 
                           A_UINT32 size)
 
5671
u8 ar6000_get_lower_threshold(s16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
 
5672
                           u32 size)
5912
5673
{
5913
 
    A_UINT32 index;
5914
 
    A_UINT8 threshold = (A_UINT8)sq_thresh->lower_threshold[size - 1];
 
5674
    u32 index;
 
5675
    u8 threshold = (u8)sq_thresh->lower_threshold[size - 1];
5915
5676
 
5916
5677
    /* The list is already in sorted order. Get the next lower value */
5917
5678
    for (index = 0; index < size; index ++) {
5918
5679
        if (rssi > sq_thresh->lower_threshold[index]) {
5919
 
            threshold = (A_UINT8)sq_thresh->lower_threshold[index];
 
5680
            threshold = (u8)sq_thresh->lower_threshold[index];
5920
5681
            break;
5921
5682
        }
5922
5683
    }
5923
5684
 
5924
5685
    return threshold;
5925
5686
}
5926
 
static A_STATUS
 
5687
static int
5927
5688
wmi_send_rssi_threshold_params(struct wmi_t *wmip,
5928
5689
                              WMI_RSSI_THRESHOLD_PARAMS_CMD *rssiCmd)
5929
5690
{
5930
5691
    void    *osbuf;
5931
 
    A_INT8  size;
 
5692
    s8 size;
5932
5693
    WMI_RSSI_THRESHOLD_PARAMS_CMD *cmd;
5933
5694
 
5934
5695
    size = sizeof (*cmd);
5942
5703
 
5943
5704
    cmd = (WMI_RSSI_THRESHOLD_PARAMS_CMD *)(A_NETBUF_DATA(osbuf));
5944
5705
    A_MEMZERO(cmd, size);
5945
 
    A_MEMCPY(cmd, rssiCmd, sizeof(WMI_RSSI_THRESHOLD_PARAMS_CMD));
 
5706
    memcpy(cmd, rssiCmd, sizeof(WMI_RSSI_THRESHOLD_PARAMS_CMD));
5946
5707
 
5947
5708
    return (wmi_cmd_send(wmip, osbuf, WMI_RSSI_THRESHOLD_PARAMS_CMDID,
5948
5709
                            NO_SYNC_WMIFLAG));
5949
5710
}
5950
 
static A_STATUS
 
5711
static int
5951
5712
wmi_send_snr_threshold_params(struct wmi_t *wmip,
5952
5713
                             WMI_SNR_THRESHOLD_PARAMS_CMD *snrCmd)
5953
5714
{
5954
5715
    void    *osbuf;
5955
 
    A_INT8  size;
 
5716
    s8 size;
5956
5717
    WMI_SNR_THRESHOLD_PARAMS_CMD *cmd;
5957
5718
 
5958
5719
    size = sizeof (*cmd);
5965
5726
    A_NETBUF_PUT(osbuf, size);
5966
5727
    cmd = (WMI_SNR_THRESHOLD_PARAMS_CMD *)(A_NETBUF_DATA(osbuf));
5967
5728
    A_MEMZERO(cmd, size);
5968
 
    A_MEMCPY(cmd, snrCmd, sizeof(WMI_SNR_THRESHOLD_PARAMS_CMD));
 
5729
    memcpy(cmd, snrCmd, sizeof(WMI_SNR_THRESHOLD_PARAMS_CMD));
5969
5730
 
5970
5731
    return (wmi_cmd_send(wmip, osbuf, WMI_SNR_THRESHOLD_PARAMS_CMDID,
5971
5732
                            NO_SYNC_WMIFLAG));
5972
5733
}
5973
5734
 
5974
 
A_STATUS
 
5735
int
5975
5736
wmi_set_target_event_report_cmd(struct wmi_t *wmip, WMI_SET_TARGET_EVENT_REPORT_CMD* cmd)
5976
5737
{
5977
5738
    void *osbuf;
5986
5747
 
5987
5748
    alloc_cmd = (WMI_SET_TARGET_EVENT_REPORT_CMD *)(A_NETBUF_DATA(osbuf));
5988
5749
    A_MEMZERO(alloc_cmd, sizeof(*cmd));
5989
 
    A_MEMCPY(alloc_cmd, cmd, sizeof(*cmd));
 
5750
    memcpy(alloc_cmd, cmd, sizeof(*cmd));
5990
5751
 
5991
5752
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_TARGET_EVENT_REPORT_CMDID,
5992
5753
            NO_SYNC_WMIFLAG));
5993
5754
}
5994
5755
 
5995
 
bss_t *wmi_rm_current_bss (struct wmi_t *wmip, A_UINT8 *id)
 
5756
bss_t *wmi_rm_current_bss (struct wmi_t *wmip, u8 *id)
5996
5757
{
5997
5758
    wmi_get_current_bssid (wmip, id);
5998
5759
    return wlan_node_remove (&wmip->wmi_scan_table, id);
5999
5760
}
6000
5761
 
6001
 
A_STATUS wmi_add_current_bss (struct wmi_t *wmip, A_UINT8 *id, bss_t *bss)
 
5762
int wmi_add_current_bss (struct wmi_t *wmip, u8 *id, bss_t *bss)
6002
5763
{
6003
5764
    wlan_setup_node (&wmip->wmi_scan_table, bss, id);
6004
 
    return A_OK;
 
5765
    return 0;
6005
5766
}
6006
5767
 
6007
 
#ifdef ATH_AR6K_11N_SUPPORT
6008
 
static A_STATUS
6009
 
wmi_addba_req_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
5768
static int
 
5769
wmi_addba_req_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6010
5770
{
6011
5771
    WMI_ADDBA_REQ_EVENT *cmd = (WMI_ADDBA_REQ_EVENT *)datap;
6012
5772
 
6013
5773
    A_WMI_AGGR_RECV_ADDBA_REQ_EVT(wmip->wmi_devt, cmd);
6014
5774
 
6015
 
    return A_OK;
 
5775
    return 0;
6016
5776
}
6017
5777
 
6018
5778
 
6019
 
static A_STATUS
6020
 
wmi_addba_resp_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
5779
static int
 
5780
wmi_addba_resp_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6021
5781
{
6022
5782
    WMI_ADDBA_RESP_EVENT *cmd = (WMI_ADDBA_RESP_EVENT *)datap;
6023
5783
 
6024
5784
    A_WMI_AGGR_RECV_ADDBA_RESP_EVT(wmip->wmi_devt, cmd);
6025
5785
 
6026
 
    return A_OK;
 
5786
    return 0;
6027
5787
}
6028
5788
 
6029
 
static A_STATUS
6030
 
wmi_delba_req_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
5789
static int
 
5790
wmi_delba_req_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6031
5791
{
6032
5792
    WMI_DELBA_EVENT *cmd = (WMI_DELBA_EVENT *)datap;
6033
5793
 
6034
5794
    A_WMI_AGGR_RECV_DELBA_REQ_EVT(wmip->wmi_devt, cmd);
6035
5795
 
6036
 
    return A_OK;
 
5796
    return 0;
6037
5797
}
6038
5798
 
6039
 
A_STATUS
6040
 
wmi_btcoex_config_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
5799
int
 
5800
wmi_btcoex_config_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6041
5801
{
6042
5802
        A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
6043
5803
 
6044
5804
    A_WMI_BTCOEX_CONFIG_EVENT(wmip->wmi_devt, datap, len);
6045
5805
 
6046
 
     return A_OK;
 
5806
     return 0;
6047
5807
}
6048
5808
 
6049
5809
 
6050
 
A_STATUS
6051
 
wmi_btcoex_stats_event_rx(struct wmi_t * wmip,A_UINT8 * datap,int len)
 
5810
int
 
5811
wmi_btcoex_stats_event_rx(struct wmi_t * wmip,u8 *datap,int len)
6052
5812
{
6053
5813
        A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
6054
5814
 
6055
5815
    A_WMI_BTCOEX_STATS_EVENT(wmip->wmi_devt, datap, len);
6056
5816
 
6057
 
     return A_OK;
 
5817
     return 0;
6058
5818
 
6059
5819
}
6060
 
#endif
6061
5820
 
6062
 
static A_STATUS
6063
 
wmi_hci_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
5821
static int
 
5822
wmi_hci_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6064
5823
{
6065
5824
    WMI_HCI_EVENT *cmd = (WMI_HCI_EVENT *)datap;
6066
5825
    A_WMI_HCI_EVENT_EVT(wmip->wmi_devt, cmd);
6067
5826
 
6068
 
    return A_OK;
 
5827
    return 0;
6069
5828
}
6070
5829
 
6071
5830
////////////////////////////////////////////////////////////////////////////////
6083
5842
 * commit cmd will not be sent to target. Without calling this IOCTL
6084
5843
 * the changes will not take effect.
6085
5844
 */
6086
 
A_STATUS
 
5845
int
6087
5846
wmi_ap_profile_commit(struct wmi_t *wmip, WMI_CONNECT_CMD *p)
6088
5847
{
6089
5848
    void *osbuf;
6098
5857
    cm = (WMI_CONNECT_CMD *)(A_NETBUF_DATA(osbuf));
6099
5858
    A_MEMZERO(cm, sizeof(*cm));
6100
5859
 
6101
 
    A_MEMCPY(cm,p,sizeof(*cm));
 
5860
    memcpy(cm,p,sizeof(*cm));
6102
5861
 
6103
5862
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_CONFIG_COMMIT_CMDID, NO_SYNC_WMIFLAG));
6104
5863
}
6109
5868
 * This command will be used to enable/disable hidden ssid functioanlity of
6110
5869
 * beacon. If it is enabled, ssid will be NULL in beacon.
6111
5870
 */
6112
 
A_STATUS
6113
 
wmi_ap_set_hidden_ssid(struct wmi_t *wmip, A_UINT8 hidden_ssid)
 
5871
int
 
5872
wmi_ap_set_hidden_ssid(struct wmi_t *wmip, u8 hidden_ssid)
6114
5873
{
6115
5874
    void *osbuf;
6116
5875
    WMI_AP_HIDDEN_SSID_CMD *hs;
6138
5897
 * is max num of STA supported by AP). Value was already validated
6139
5898
 * in ioctl.c
6140
5899
 */
6141
 
A_STATUS
6142
 
wmi_ap_set_num_sta(struct wmi_t *wmip, A_UINT8 num_sta)
 
5900
int
 
5901
wmi_ap_set_num_sta(struct wmi_t *wmip, u8 num_sta)
6143
5902
{
6144
5903
    void *osbuf;
6145
5904
    WMI_AP_SET_NUM_STA_CMD *ns;
6166
5925
 * be allowed to connect with this AP. When this list is empty
6167
5926
 * firware will allow all STAs till the count reaches AP_MAX_NUM_STA.
6168
5927
 */
6169
 
A_STATUS
 
5928
int
6170
5929
wmi_ap_acl_mac_list(struct wmi_t *wmip, WMI_AP_ACL_MAC_CMD *acl)
6171
5930
{
6172
5931
    void *osbuf;
6180
5939
    A_NETBUF_PUT(osbuf, sizeof(WMI_AP_ACL_MAC_CMD));
6181
5940
    a = (WMI_AP_ACL_MAC_CMD *)(A_NETBUF_DATA(osbuf));
6182
5941
    A_MEMZERO(a, sizeof(*a));
6183
 
    A_MEMCPY(a,acl,sizeof(*acl));
 
5942
    memcpy(a,acl,sizeof(*acl));
6184
5943
 
6185
5944
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_ACL_MAC_LIST_CMDID, NO_SYNC_WMIFLAG));
6186
5945
}
6192
5951
 * be allowed to connect with this AP. When this list is empty
6193
5952
 * firware will allow all STAs till the count reaches AP_MAX_NUM_STA.
6194
5953
 */
6195
 
A_STATUS
6196
 
wmi_ap_set_mlme(struct wmi_t *wmip, A_UINT8 cmd, A_UINT8 *mac, A_UINT16 reason)
 
5954
int
 
5955
wmi_ap_set_mlme(struct wmi_t *wmip, u8 cmd, u8 *mac, u16 reason)
6197
5956
{
6198
5957
    void *osbuf;
6199
5958
    WMI_AP_SET_MLME_CMD *mlme;
6208
5967
    A_MEMZERO(mlme, sizeof(*mlme));
6209
5968
 
6210
5969
    mlme->cmd = cmd;
6211
 
    A_MEMCPY(mlme->mac, mac, ATH_MAC_LEN);
 
5970
    memcpy(mlme->mac, mac, ATH_MAC_LEN);
6212
5971
    mlme->reason = reason;
6213
5972
 
6214
5973
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_SET_MLME_CMDID, NO_SYNC_WMIFLAG));
6215
5974
}
6216
5975
 
6217
 
static A_STATUS
6218
 
wmi_pspoll_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 
5976
static int
 
5977
wmi_pspoll_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6219
5978
{
6220
5979
    WMI_PSPOLL_EVENT *ev;
6221
5980
 
6225
5984
    ev = (WMI_PSPOLL_EVENT *)datap;
6226
5985
 
6227
5986
    A_WMI_PSPOLL_EVENT(wmip->wmi_devt, ev->aid);
6228
 
    return A_OK;
 
5987
    return 0;
6229
5988
}
6230
5989
 
6231
 
static A_STATUS
6232
 
wmi_dtimexpiry_event_rx(struct wmi_t *wmip, A_UINT8 *datap,int len)
 
5990
static int
 
5991
wmi_dtimexpiry_event_rx(struct wmi_t *wmip, u8 *datap,int len)
6233
5992
{
6234
5993
    A_WMI_DTIMEXPIRY_EVENT(wmip->wmi_devt);
6235
 
    return A_OK;
 
5994
    return 0;
6236
5995
}
6237
5996
 
6238
5997
#ifdef WAPI_ENABLE
6239
 
static A_STATUS
6240
 
wmi_wapi_rekey_event_rx(struct wmi_t *wmip, A_UINT8 *datap,int len)
 
5998
static int
 
5999
wmi_wapi_rekey_event_rx(struct wmi_t *wmip, u8 *datap,int len)
6241
6000
{
6242
 
    A_UINT8 *ev;
 
6001
    u8 *ev;
6243
6002
 
6244
6003
    if (len < 7) {
6245
6004
        return A_EINVAL;
6246
6005
    }
6247
 
    ev = (A_UINT8 *)datap;
 
6006
    ev = (u8 *)datap;
6248
6007
 
6249
6008
    A_WMI_WAPI_REKEY_EVENT(wmip->wmi_devt, *ev, &ev[1]);
6250
 
    return A_OK;
 
6009
    return 0;
6251
6010
}
6252
6011
#endif
6253
6012
 
6254
 
A_STATUS
6255
 
wmi_set_pvb_cmd(struct wmi_t *wmip, A_UINT16 aid, A_BOOL flag)
 
6013
int
 
6014
wmi_set_pvb_cmd(struct wmi_t *wmip, u16 aid, bool flag)
6256
6015
{
6257
6016
    WMI_AP_SET_PVB_CMD *cmd;
6258
6017
    void *osbuf = NULL;
6272
6031
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_SET_PVB_CMDID, NO_SYNC_WMIFLAG));
6273
6032
}
6274
6033
 
6275
 
A_STATUS
6276
 
wmi_ap_conn_inact_time(struct wmi_t *wmip, A_UINT32 period)
 
6034
int
 
6035
wmi_ap_conn_inact_time(struct wmi_t *wmip, u32 period)
6277
6036
{
6278
6037
    WMI_AP_CONN_INACT_CMD *cmd;
6279
6038
    void *osbuf = NULL;
6292
6051
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_CONN_INACT_CMDID, NO_SYNC_WMIFLAG));
6293
6052
}
6294
6053
 
6295
 
A_STATUS
6296
 
wmi_ap_bgscan_time(struct wmi_t *wmip, A_UINT32 period, A_UINT32 dwell)
 
6054
int
 
6055
wmi_ap_bgscan_time(struct wmi_t *wmip, u32 period, u32 dwell)
6297
6056
{
6298
6057
    WMI_AP_PROT_SCAN_TIME_CMD *cmd;
6299
6058
    void *osbuf = NULL;
6313
6072
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_PROT_SCAN_TIME_CMDID, NO_SYNC_WMIFLAG));
6314
6073
}
6315
6074
 
6316
 
A_STATUS
6317
 
wmi_ap_set_dtim(struct wmi_t *wmip, A_UINT8 dtim)
 
6075
int
 
6076
wmi_ap_set_dtim(struct wmi_t *wmip, u8 dtim)
6318
6077
{
6319
6078
    WMI_AP_SET_DTIM_CMD *cmd;
6320
6079
    void *osbuf = NULL;
6341
6100
 * OR with AP_ACL_RETAIN_LIST_MASK, else the existing list will be cleared.
6342
6101
 * If there is no chage in policy, the list will be intact.
6343
6102
 */
6344
 
A_STATUS
6345
 
wmi_ap_set_acl_policy(struct wmi_t *wmip, A_UINT8 policy)
 
6103
int
 
6104
wmi_ap_set_acl_policy(struct wmi_t *wmip, u8 policy)
6346
6105
{
6347
6106
    void *osbuf;
6348
6107
    WMI_AP_ACL_POLICY_CMD *po;
6361
6120
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_ACL_POLICY_CMDID, NO_SYNC_WMIFLAG));
6362
6121
}
6363
6122
 
6364
 
A_STATUS
6365
 
wmi_ap_set_rateset(struct wmi_t *wmip, A_UINT8 rateset)
 
6123
int
 
6124
wmi_ap_set_rateset(struct wmi_t *wmip, u8 rateset)
6366
6125
{
6367
6126
    void *osbuf;
6368
6127
    WMI_AP_SET_11BG_RATESET_CMD *rs;
6381
6140
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_SET_11BG_RATESET_CMDID, NO_SYNC_WMIFLAG));
6382
6141
}
6383
6142
 
6384
 
#ifdef ATH_AR6K_11N_SUPPORT
6385
 
A_STATUS
 
6143
int
6386
6144
wmi_set_ht_cap_cmd(struct wmi_t *wmip, WMI_SET_HT_CAP_CMD *cmd)
6387
6145
{
6388
6146
    void *osbuf;
6389
6147
    WMI_SET_HT_CAP_CMD *htCap;
6390
 
    A_UINT8 band;
 
6148
    u8 band;
6391
6149
 
6392
6150
    osbuf = A_NETBUF_ALLOC(sizeof(*htCap));
6393
6151
    if (osbuf == NULL) {
6401
6159
 
6402
6160
    htCap = (WMI_SET_HT_CAP_CMD *)(A_NETBUF_DATA(osbuf));
6403
6161
    A_MEMZERO(htCap, sizeof(*htCap));
6404
 
    A_MEMCPY(htCap, cmd, sizeof(*htCap));
 
6162
    memcpy(htCap, cmd, sizeof(*htCap));
6405
6163
 
6406
6164
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_HT_CAP_CMDID,
6407
6165
                         NO_SYNC_WMIFLAG));
6408
6166
}
6409
6167
 
6410
 
A_STATUS
6411
 
wmi_set_ht_op_cmd(struct wmi_t *wmip, A_UINT8 sta_chan_width)
 
6168
int
 
6169
wmi_set_ht_op_cmd(struct wmi_t *wmip, u8 sta_chan_width)
6412
6170
{
6413
6171
    void *osbuf;
6414
6172
    WMI_SET_HT_OP_CMD *htInfo;
6427
6185
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_HT_OP_CMDID,
6428
6186
                         NO_SYNC_WMIFLAG));
6429
6187
}
6430
 
#endif
6431
6188
 
6432
 
A_STATUS
6433
 
wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, A_UINT32 *pMaskArray)
 
6189
int
 
6190
wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, u32 *pMaskArray)
6434
6191
{
6435
6192
    void *osbuf;
6436
6193
    WMI_SET_TX_SELECT_RATES_CMD *pData;
6443
6200
    A_NETBUF_PUT(osbuf, sizeof(*pData));
6444
6201
 
6445
6202
    pData = (WMI_SET_TX_SELECT_RATES_CMD *)(A_NETBUF_DATA(osbuf));
6446
 
    A_MEMCPY(pData, pMaskArray, sizeof(*pData));
 
6203
    memcpy(pData, pMaskArray, sizeof(*pData));
6447
6204
 
6448
6205
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_TX_SELECT_RATES_CMDID,
6449
6206
                         NO_SYNC_WMIFLAG));
6450
6207
}
6451
6208
 
6452
6209
 
6453
 
A_STATUS
6454
 
wmi_send_hci_cmd(struct wmi_t *wmip, A_UINT8 *buf, A_UINT16 sz)
 
6210
int
 
6211
wmi_send_hci_cmd(struct wmi_t *wmip, u8 *buf, u16 sz)
6455
6212
{
6456
6213
    void *osbuf;
6457
6214
    WMI_HCI_CMD *cmd;
6465
6222
    cmd = (WMI_HCI_CMD *)(A_NETBUF_DATA(osbuf));
6466
6223
 
6467
6224
    cmd->cmd_buf_sz = sz;
6468
 
    A_MEMCPY(cmd->buf, buf, sz);
 
6225
    memcpy(cmd->buf, buf, sz);
6469
6226
    return (wmi_cmd_send(wmip, osbuf, WMI_HCI_CMD_CMDID, NO_SYNC_WMIFLAG));
6470
6227
}
6471
6228
 
6472
 
#ifdef ATH_AR6K_11N_SUPPORT
6473
 
A_STATUS
6474
 
wmi_allow_aggr_cmd(struct wmi_t *wmip, A_UINT16 tx_tidmask, A_UINT16 rx_tidmask)
 
6229
int
 
6230
wmi_allow_aggr_cmd(struct wmi_t *wmip, u16 tx_tidmask, u16 rx_tidmask)
6475
6231
{
6476
6232
    void *osbuf;
6477
6233
    WMI_ALLOW_AGGR_CMD *cmd;
6490
6246
    return (wmi_cmd_send(wmip, osbuf, WMI_ALLOW_AGGR_CMDID, NO_SYNC_WMIFLAG));
6491
6247
}
6492
6248
 
6493
 
A_STATUS
6494
 
wmi_setup_aggr_cmd(struct wmi_t *wmip, A_UINT8 tid)
 
6249
int
 
6250
wmi_setup_aggr_cmd(struct wmi_t *wmip, u8 tid)
6495
6251
{
6496
6252
    void *osbuf;
6497
6253
    WMI_ADDBA_REQ_CMD *cmd;
6509
6265
    return (wmi_cmd_send(wmip, osbuf, WMI_ADDBA_REQ_CMDID, NO_SYNC_WMIFLAG));
6510
6266
}
6511
6267
 
6512
 
A_STATUS
6513
 
wmi_delete_aggr_cmd(struct wmi_t *wmip, A_UINT8 tid, A_BOOL uplink)
 
6268
int
 
6269
wmi_delete_aggr_cmd(struct wmi_t *wmip, u8 tid, bool uplink)
6514
6270
{
6515
6271
    void *osbuf;
6516
6272
    WMI_DELBA_REQ_CMD *cmd;
6529
6285
    /* Delete the local aggr state, on host */
6530
6286
    return (wmi_cmd_send(wmip, osbuf, WMI_DELBA_REQ_CMDID, NO_SYNC_WMIFLAG));
6531
6287
}
6532
 
#endif
6533
6288
 
6534
 
A_STATUS
6535
 
wmi_set_rx_frame_format_cmd(struct wmi_t *wmip, A_UINT8 rxMetaVersion,
6536
 
                            A_BOOL rxDot11Hdr, A_BOOL defragOnHost)
 
6289
int
 
6290
wmi_set_rx_frame_format_cmd(struct wmi_t *wmip, u8 rxMetaVersion,
 
6291
                            bool rxDot11Hdr, bool defragOnHost)
6537
6292
{
6538
6293
    void *osbuf;
6539
6294
    WMI_RX_FRAME_FORMAT_CMD *cmd;
6546
6301
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
6547
6302
 
6548
6303
    cmd = (WMI_RX_FRAME_FORMAT_CMD *)(A_NETBUF_DATA(osbuf));
6549
 
    cmd->dot11Hdr = (rxDot11Hdr==TRUE)? 1:0;
6550
 
    cmd->defragOnHost = (defragOnHost==TRUE)? 1:0;
 
6304
    cmd->dot11Hdr = (rxDot11Hdr==true)? 1:0;
 
6305
    cmd->defragOnHost = (defragOnHost==true)? 1:0;
6551
6306
    cmd->metaVersion = rxMetaVersion;  /*  */
6552
6307
 
6553
6308
    /* Delete the local aggr state, on host */
6555
6310
}
6556
6311
 
6557
6312
 
6558
 
A_STATUS
6559
 
wmi_set_thin_mode_cmd(struct wmi_t *wmip, A_BOOL bThinMode)
 
6313
int
 
6314
wmi_set_thin_mode_cmd(struct wmi_t *wmip, bool bThinMode)
6560
6315
{
6561
6316
    void *osbuf;
6562
6317
    WMI_SET_THIN_MODE_CMD *cmd;
6569
6324
    A_NETBUF_PUT(osbuf, sizeof(*cmd));
6570
6325
 
6571
6326
    cmd = (WMI_SET_THIN_MODE_CMD *)(A_NETBUF_DATA(osbuf));
6572
 
    cmd->enable = (bThinMode==TRUE)? 1:0;
 
6327
    cmd->enable = (bThinMode==true)? 1:0;
6573
6328
 
6574
6329
    /* Delete the local aggr state, on host */
6575
6330
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_THIN_MODE_CMDID, NO_SYNC_WMIFLAG));
6576
6331
}
6577
6332
 
6578
6333
 
6579
 
A_STATUS
 
6334
int
6580
6335
wmi_set_wlan_conn_precedence_cmd(struct wmi_t *wmip, BT_WLAN_CONN_PRECEDENCE precedence)
6581
6336
{
6582
6337
    void *osbuf;
6597
6352
                         NO_SYNC_WMIFLAG));
6598
6353
}
6599
6354
 
6600
 
A_STATUS
6601
 
wmi_set_pmk_cmd(struct wmi_t *wmip, A_UINT8 *pmk)
 
6355
int
 
6356
wmi_set_pmk_cmd(struct wmi_t *wmip, u8 *pmk)
6602
6357
{
6603
6358
    void *osbuf;
6604
6359
    WMI_SET_PMK_CMD *p;
6613
6368
    p = (WMI_SET_PMK_CMD *)(A_NETBUF_DATA(osbuf));
6614
6369
    A_MEMZERO(p, sizeof(*p));
6615
6370
 
6616
 
    A_MEMCPY(p->pmk, pmk, WMI_PMK_LEN);
 
6371
    memcpy(p->pmk, pmk, WMI_PMK_LEN);
6617
6372
 
6618
6373
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_PMK_CMDID, NO_SYNC_WMIFLAG));
6619
6374
}
6620
6375
 
6621
 
A_STATUS
6622
 
wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, A_UINT8 sgiPERThreshold)
 
6376
int
 
6377
wmi_set_excess_tx_retry_thres_cmd(struct wmi_t *wmip, WMI_SET_EXCESS_TX_RETRY_THRES_CMD *cmd)
 
6378
{
 
6379
    void *osbuf;
 
6380
    WMI_SET_EXCESS_TX_RETRY_THRES_CMD *p;
 
6381
 
 
6382
    osbuf = A_NETBUF_ALLOC(sizeof(WMI_SET_EXCESS_TX_RETRY_THRES_CMD));
 
6383
    if (osbuf == NULL) {
 
6384
        return A_NO_MEMORY;
 
6385
    }
 
6386
 
 
6387
    A_NETBUF_PUT(osbuf, sizeof(WMI_SET_EXCESS_TX_RETRY_THRES_CMD));
 
6388
 
 
6389
    p = (WMI_SET_EXCESS_TX_RETRY_THRES_CMD *)(A_NETBUF_DATA(osbuf));
 
6390
    memset(p, 0, sizeof(*p));
 
6391
 
 
6392
    p->threshold = cmd->threshold;
 
6393
 
 
6394
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_EXCESS_TX_RETRY_THRES_CMDID, NO_SYNC_WMIFLAG));
 
6395
}
 
6396
 
 
6397
int
 
6398
wmi_SGI_cmd(struct wmi_t *wmip, u32 sgiMask, u8 sgiPERThreshold)
6623
6399
{
6624
6400
    void *osbuf;
6625
6401
    WMI_SET_TX_SGI_PARAM_CMD *cmd;
6640
6416
}
6641
6417
 
6642
6418
bss_t *
6643
 
wmi_find_matching_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
6644
 
                   A_UINT32 ssidLength,
6645
 
                   A_UINT32 dot11AuthMode, A_UINT32 authMode,
6646
 
                   A_UINT32 pairwiseCryptoType, A_UINT32 grpwiseCryptoTyp)
 
6419
wmi_find_matching_Ssidnode (struct wmi_t *wmip, u8 *pSsid,
 
6420
                   u32 ssidLength,
 
6421
                   u32 dot11AuthMode, u32 authMode,
 
6422
                   u32 pairwiseCryptoType, u32 grpwiseCryptoTyp)
6647
6423
{
6648
6424
    bss_t *node = NULL;
6649
6425
    node = wlan_find_matching_Ssidnode (&wmip->wmi_scan_table, pSsid,
6652
6428
    return node;
6653
6429
}
6654
6430
 
6655
 
A_UINT16
6656
 
wmi_ieee2freq (int chan)
 
6431
u16 wmi_ieee2freq (int chan)
6657
6432
{
6658
 
    A_UINT16 freq = 0;
 
6433
    u16 freq = 0;
6659
6434
    freq = wlan_ieee2freq (chan);
6660
6435
    return freq;
6661
6436
 
6662
6437
}
6663
6438
 
6664
 
A_UINT32
6665
 
wmi_freq2ieee (A_UINT16 freq)
 
6439
u32 wmi_freq2ieee (u16 freq)
6666
6440
{
6667
 
    A_UINT16 chan = 0;
 
6441
    u16 chan = 0;
6668
6442
    chan = wlan_freq2ieee (freq);
6669
6443
    return chan;
6670
6444
}