← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

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"
129
127
static int
130
128
wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, u32 len);
131
129
 
132
 
static int
133
 
wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, u32 len);
134
 
 
135
 
#ifdef CONFIG_HOST_GPIO_SUPPORT
136
 
static int wmi_gpio_intr_rx(struct wmi_t *wmip, u8 *datap, int len);
137
 
static int wmi_gpio_data_rx(struct wmi_t *wmip, u8 *datap, int len);
138
 
static int wmi_gpio_ack_rx(struct wmi_t *wmip, u8 *datap, int len);
139
 
#endif /* CONFIG_HOST_GPIO_SUPPORT */
140
130
 
141
131
#ifdef CONFIG_HOST_TCMD_SUPPORT
142
132
static int
187
177
 
188
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
180
static int wmi_addba_req_event_rx(struct wmi_t *, u8 *, int);
192
181
static int wmi_addba_resp_event_rx(struct wmi_t *, u8 *, int);
193
182
static int wmi_delba_req_event_rx(struct wmi_t *, u8 *, int);
194
183
static int wmi_btcoex_config_event_rx(struct wmi_t *wmip, u8 *datap, int len);
195
184
static int wmi_btcoex_stats_event_rx(struct wmi_t *wmip, u8 *datap, int len);
196
 
#endif
197
185
static int wmi_hci_event_rx(struct wmi_t *, u8 *, int);
198
186
 
199
187
#ifdef WAPI_ENABLE
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
266
    u8 ip_ver_hdrlen;          /* version and hdr length */
292
278
    u8 ip_dst[4];
293
279
} POSTPACK iphdr;
294
280
 
295
 
#include "athendpack.h"
296
 
 
297
281
static s16 rssi_event_value = 0;
298
282
static s16 snr_event_value = 0;
299
283
 
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
 
475
459
                *pVersion = WMI_META_VERSION_1;
476
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 ;
487
470
                memcpy(pV2,(WMI_TX_META_V2 *)pTxMetaS,sizeof(WMI_TX_META_V2));
488
471
                return (0);
489
472
                }
490
 
#endif
491
473
        default:
492
474
                return (0);
493
475
    }
525
507
    }
526
508
 
527
509
    WMI_DATA_HDR_SET_META(dtHdr, metaVersion);
528
 
    //dtHdr->rssi = 0;
 
510
 
 
511
    dtHdr->info3 = 0;
529
512
 
530
513
    return (0);
531
514
}
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;
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));
1014
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;
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)
 
1161
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
1212
1162
static int
1213
1163
wmi_simple_cmd_xtnd(struct wmi_t *wmip, WMIX_COMMAND_ID cmdid)
1214
1164
{
2298
2248
    return 0;
2299
2249
}
2300
2250
 
2301
 
#ifdef CONFIG_HOST_GPIO_SUPPORT
2302
 
static int
2303
 
wmi_gpio_intr_rx(struct wmi_t *wmip, u8 *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 0;
2314
 
}
2315
 
 
2316
 
static int
2317
 
wmi_gpio_data_rx(struct wmi_t *wmip, u8 *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 0;
2328
 
}
2329
 
 
2330
 
static int
2331
 
wmi_gpio_ack_rx(struct wmi_t *wmip, u8 *datap, int len)
2332
 
{
2333
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
2334
 
 
2335
 
    A_WMI_GPIO_ACK_RX();
2336
 
 
2337
 
    return 0;
2338
 
}
2339
 
#endif /* CONFIG_HOST_GPIO_SUPPORT */
2340
 
 
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.
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));
4282
4193
                         NO_SYNC_WMIFLAG));
4283
4194
}
4284
4195
 
4285
 
#ifdef CONFIG_HOST_GPIO_SUPPORT
4286
 
/* Send a command to Target to change GPIO output pins. */
4287
 
int
4288
 
wmi_gpio_output_set(struct wmi_t *wmip,
4289
 
                    u32 set_mask,
4290
 
                    u32 clear_mask,
4291
 
                    u32 enable_mask,
4292
 
                    u32 disable_mask)
4293
 
{
4294
 
    void *osbuf;
4295
 
    WMIX_GPIO_OUTPUT_SET_CMD *output_set;
4296
 
    int size;
4297
 
 
4298
 
    size = sizeof(*output_set);
4299
 
 
4300
 
    A_DPRINTF(DBG_WMI,
4301
 
        (DBGFMT "Enter - set=0x%x clear=0x%x enb=0x%x dis=0x%x\n", DBGARG,
4302
 
        set_mask, clear_mask, enable_mask, disable_mask));
4303
 
 
4304
 
    osbuf = A_NETBUF_ALLOC(size);
4305
 
    if (osbuf == NULL) {
4306
 
        return A_NO_MEMORY;
4307
 
    }
4308
 
    A_NETBUF_PUT(osbuf, size);
4309
 
    output_set = (WMIX_GPIO_OUTPUT_SET_CMD *)(A_NETBUF_DATA(osbuf));
4310
 
 
4311
 
    output_set->set_mask                   = set_mask;
4312
 
    output_set->clear_mask                 = clear_mask;
4313
 
    output_set->enable_mask                = enable_mask;
4314
 
    output_set->disable_mask               = disable_mask;
4315
 
 
4316
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_OUTPUT_SET_CMDID,
4317
 
                             NO_SYNC_WMIFLAG));
4318
 
}
4319
 
 
4320
 
/* Send a command to the Target requesting state of the GPIO input pins */
4321
 
int
4322
 
wmi_gpio_input_get(struct wmi_t *wmip)
4323
 
{
4324
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
4325
 
 
4326
 
    return wmi_simple_cmd_xtnd(wmip, WMIX_GPIO_INPUT_GET_CMDID);
4327
 
}
4328
 
 
4329
 
/* Send a command to the Target that changes the value of a GPIO register. */
4330
 
int
4331
 
wmi_gpio_register_set(struct wmi_t *wmip,
4332
 
                      u32 gpioreg_id,
4333
 
                      u32 value)
4334
 
{
4335
 
    void *osbuf;
4336
 
    WMIX_GPIO_REGISTER_SET_CMD *register_set;
4337
 
    int size;
4338
 
 
4339
 
    size = sizeof(*register_set);
4340
 
 
4341
 
    A_DPRINTF(DBG_WMI,
4342
 
        (DBGFMT "Enter - reg=%d value=0x%x\n", DBGARG, gpioreg_id, value));
4343
 
 
4344
 
    osbuf = A_NETBUF_ALLOC(size);
4345
 
    if (osbuf == NULL) {
4346
 
        return A_NO_MEMORY;
4347
 
    }
4348
 
    A_NETBUF_PUT(osbuf, size);
4349
 
    register_set = (WMIX_GPIO_REGISTER_SET_CMD *)(A_NETBUF_DATA(osbuf));
4350
 
 
4351
 
    register_set->gpioreg_id               = gpioreg_id;
4352
 
    register_set->value                    = value;
4353
 
 
4354
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_REGISTER_SET_CMDID,
4355
 
                             NO_SYNC_WMIFLAG));
4356
 
}
4357
 
 
4358
 
/* Send a command to the Target to fetch the value of a GPIO register. */
4359
 
int
4360
 
wmi_gpio_register_get(struct wmi_t *wmip,
4361
 
                      u32 gpioreg_id)
4362
 
{
4363
 
    void *osbuf;
4364
 
    WMIX_GPIO_REGISTER_GET_CMD *register_get;
4365
 
    int size;
4366
 
 
4367
 
    size = sizeof(*register_get);
4368
 
 
4369
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter - reg=%d\n", DBGARG, gpioreg_id));
4370
 
 
4371
 
    osbuf = A_NETBUF_ALLOC(size);
4372
 
    if (osbuf == NULL) {
4373
 
        return A_NO_MEMORY;
4374
 
    }
4375
 
    A_NETBUF_PUT(osbuf, size);
4376
 
    register_get = (WMIX_GPIO_REGISTER_GET_CMD *)(A_NETBUF_DATA(osbuf));
4377
 
 
4378
 
    register_get->gpioreg_id               = gpioreg_id;
4379
 
 
4380
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_REGISTER_GET_CMDID,
4381
 
                             NO_SYNC_WMIFLAG));
4382
 
}
4383
 
 
4384
 
/* Send a command to the Target acknowledging some GPIO interrupts. */
4385
 
int
4386
 
wmi_gpio_intr_ack(struct wmi_t *wmip,
4387
 
                  u32 ack_mask)
4388
 
{
4389
 
    void *osbuf;
4390
 
    WMIX_GPIO_INTR_ACK_CMD *intr_ack;
4391
 
    int size;
4392
 
 
4393
 
    size = sizeof(*intr_ack);
4394
 
 
4395
 
    A_DPRINTF(DBG_WMI, (DBGFMT "Enter ack_mask=0x%x\n", DBGARG, ack_mask));
4396
 
 
4397
 
    osbuf = A_NETBUF_ALLOC(size);
4398
 
    if (osbuf == NULL) {
4399
 
        return A_NO_MEMORY;
4400
 
    }
4401
 
    A_NETBUF_PUT(osbuf, size);
4402
 
    intr_ack = (WMIX_GPIO_INTR_ACK_CMD *)(A_NETBUF_DATA(osbuf));
4403
 
 
4404
 
    intr_ack->ack_mask               = ack_mask;
4405
 
 
4406
 
    return (wmi_cmd_send_xtnd(wmip, osbuf, WMIX_GPIO_INTR_ACK_CMDID,
4407
 
                             NO_SYNC_WMIFLAG));
4408
 
}
4409
 
#endif /* CONFIG_HOST_GPIO_SUPPORT */
4410
 
 
4411
4196
int
4412
4197
wmi_set_access_params_cmd(struct wmi_t *wmip, u8 ac,  u16 txop, u8 eCWmin,
4413
4198
                          u8 eCWmax, u8 aifsn)
4683
4468
 
4684
4469
   A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
4685
4470
 
4686
 
   A_WMI_TCMD_RX_REPORT_EVENT(wmip->wmi_devt, datap, len);
4687
 
 
4688
4471
   return 0;
4689
4472
}
4690
4473
 
5500
5283
}
5501
5284
 
5502
5285
 
5503
 
 
5504
 
static int
5505
 
wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, u32 len)
5506
 
{
5507
 
    WMI_ACM_REJECT_EVENT *ev;
5508
 
 
5509
 
    ev = (WMI_ACM_REJECT_EVENT *)datap;
5510
 
    wmip->wmi_traffic_class = ev->trafficClass;
5511
 
    printk("ACM REJECT %d\n",wmip->wmi_traffic_class);
5512
 
    return 0;
5513
 
}
5514
 
 
5515
 
 
5516
5286
#ifdef CONFIG_HOST_DSET_SUPPORT
5517
5287
int
5518
5288
wmi_dset_data_reply(struct wmi_t *wmip,
5877
5647
 
5878
5648
    ar6000_scan_indication (wmip->wmi_devt, pAr6kScanIndEvent, size);
5879
5649
 
5880
 
    A_FREE(pAr6kScanIndEvent);
 
5650
    kfree(pAr6kScanIndEvent);
5881
5651
}
5882
5652
#endif
5883
5653
 
5995
5765
    return 0;
5996
5766
}
5997
5767
 
5998
 
#ifdef ATH_AR6K_11N_SUPPORT
5999
5768
static int
6000
5769
wmi_addba_req_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6001
5770
{
6048
5817
     return 0;
6049
5818
 
6050
5819
}
6051
 
#endif
6052
5820
 
6053
5821
static int
6054
5822
wmi_hci_event_rx(struct wmi_t *wmip, u8 *datap, int len)
6372
6140
    return (wmi_cmd_send(wmip, osbuf, WMI_AP_SET_11BG_RATESET_CMDID, NO_SYNC_WMIFLAG));
6373
6141
}
6374
6142
 
6375
 
#ifdef ATH_AR6K_11N_SUPPORT
6376
6143
int
6377
6144
wmi_set_ht_cap_cmd(struct wmi_t *wmip, WMI_SET_HT_CAP_CMD *cmd)
6378
6145
{
6418
6185
    return (wmi_cmd_send(wmip, osbuf, WMI_SET_HT_OP_CMDID,
6419
6186
                         NO_SYNC_WMIFLAG));
6420
6187
}
6421
 
#endif
6422
6188
 
6423
6189
int
6424
6190
wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, u32 *pMaskArray)
6460
6226
    return (wmi_cmd_send(wmip, osbuf, WMI_HCI_CMD_CMDID, NO_SYNC_WMIFLAG));
6461
6227
}
6462
6228
 
6463
 
#ifdef ATH_AR6K_11N_SUPPORT
6464
6229
int
6465
6230
wmi_allow_aggr_cmd(struct wmi_t *wmip, u16 tx_tidmask, u16 rx_tidmask)
6466
6231
{
6520
6285
    /* Delete the local aggr state, on host */
6521
6286
    return (wmi_cmd_send(wmip, osbuf, WMI_DELBA_REQ_CMDID, NO_SYNC_WMIFLAG));
6522
6287
}
6523
 
#endif
6524
6288
 
6525
6289
int
6526
6290
wmi_set_rx_frame_format_cmd(struct wmi_t *wmip, u8 rxMetaVersion,