wmi.c

linux下的SDIO 驱动

static A_STATUS
wmi_sync_point(struct wmi_t *wmip)
{
    void *cmd_osbuf, *be_osbuf, *pri_osbuf[WMI_MAX_NUM_PRI_STREAMS];
    A_UINT8 i;
    A_STATUS status;

    WMI_DEBUG_PRINTF("wmi_sync_point\n");
    /*
     * We allocate all network buffers needed so we will be able to
     * send all required frames.
     */
    cmd_osbuf = a_netbuf_alloc(0);      /* no payload */
    if (cmd_osbuf == NULL) {
        return A_NO_MEMORY;
    }
    be_osbuf = a_netbuf_alloc(0);      /* no payload */
    if (be_osbuf == NULL) {
        a_netbuf_free(cmd_osbuf);
        return A_NO_MEMORY;
    }

    for (i = 0; i < wmip->wmi_numQoSStream; i++) {
        pri_osbuf[i] = a_netbuf_alloc(0);      /* no payload */
        if (pri_osbuf[i] == NULL) {
            A_UINT8 j;
            a_netbuf_free(be_osbuf);
            a_netbuf_free(cmd_osbuf);
            /* free previously allocated bufs */
            for (j = 0; j < i; j++) {
                a_netbuf_free(pri_osbuf[j]);
            }
            return A_NO_MEMORY;
        }
    }

    /*
     * Send sync cmd followed by sync data messages on all endpoints being
     * used
     */
    status = wmi_cmd_send(wmip, cmd_osbuf, WMI_SYNCHRONIZE_CMDID,
                          NO_SYNC_WMIFLAG);

    if (status == A_OK) {
        status = wmi_dataSync_send(wmip, be_osbuf, WMI_BEST_EFFORT_MBOX);
    }

    if (status == A_OK) {
        A_UINT8 priIndex = 0;
        for (i = 0; i < wmip->wmi_numQoSStream; i++) {
            while (priIndex < WMI_MAX_NUM_PRI_STREAMS &&
                  (!wmip->wmi_priority[priIndex].inUse)) {
                priIndex++;
            }
            if (priIndex >= WMI_MAX_NUM_PRI_STREAMS) {
                break;
            }
            status = wmi_dataSync_send(wmip, pri_osbuf[i], wmip->wmi_priority[priIndex].mbox);
            if (status != A_OK) {
                break;
            }
            priIndex++;
        }
    }

    return (status);
}

A_STATUS
wmi_create_pstream_cmd(struct wmi_t *wmip, WMI_CREATE_PSTREAM_CMD *params)
{
    void *osbuf;
    WMI_CREATE_PSTREAM_CMD *cmd;

    /* Validate all the parameters. */
    if( !((params->userPriority < 8) &&
         (params->trafficDirection == BIDIR_TRAFFIC ||
            params->trafficDirection == UPLINK_TRAFFIC ||
            params->trafficDirection == DNLINK_TRAFFIC ) &&
         (params->userPriority <= 0x7) &&
         (convert_userPriority_to_trafficClass(params->userPriority) == params->trafficClass)  &&
         (params->trafficClass != WMM_AC_BE)  &&
         (params->trafficType == TRAFFIC_TYPE_APERIODIC ||
            params->trafficType == TRAFFIC_TYPE_PERIODIC ) &&
         (params->voicePSCapability == DISABLE_FOR_THIS_AC  ||
            params->voicePSCapability == ENABLE_FOR_THIS_AC ||
            params->voicePSCapability == ENABLE_FOR_ALL_AC) &&
         (params->tsid < 15)) )
    {
        return  A_EINVAL;
    }


    if (params->trafficDirection == BIDIR_TRAFFIC) {
        if (wmip->wmi_pstreamCmdInProgress[UPLINK_TRAFFIC][params->trafficClass]
          || wmip->wmi_pstreamCmdInProgress[DNLINK_TRAFFIC][params->trafficClass]
          || wmip->wmi_cpstreamCmdInProgress) {
            WMI_DEBUG_PRINTF("create %d too busy !\n",params->trafficClass);
            return A_EBUSY;
        }
        wmip->wmi_pstreamCmdInProgress[UPLINK_TRAFFIC][params->trafficClass] = TRUE;
        wmip->wmi_pstreamCmdInProgress[DNLINK_TRAFFIC][params->trafficClass] = TRUE;
    } else {
        if (wmip->wmi_pstreamCmdInProgress[params->trafficDirection][params->trafficClass]
         || wmip->wmi_cpstreamCmdInProgress) {
            WMI_DEBUG_PRINTF("create %d too busy !\n",params->trafficClass);
            return A_EBUSY;
        }
        wmip->wmi_pstreamCmdInProgress[params->trafficDirection][params->trafficClass] = TRUE;
    }

    osbuf = a_netbuf_alloc(sizeof(*cmd));
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    wmip->wmi_cpstreamCmdInProgress = TRUE;
    a_netbuf_put(osbuf, sizeof(*cmd));

    WMI_DEBUG_PRINTF("Sending create_pstream_cmd: ac=%d, rxQ=%d, dir=%d\n",
                     params->trafficClass, params->rxQueueNum, params->trafficDirection);
    cmd = (WMI_CREATE_PSTREAM_CMD *)(a_netbuf_to_data(osbuf));
    A_MEMZERO(cmd, sizeof(*cmd));
    A_MEMCPY(cmd, params, sizeof(*cmd));

    if (params->rxQueueNum == 0xFF) {
        if(wmip->wmi_trafficClassMap[DNLINK_TRAFFIC][params->trafficClass] != WMI_NOT_MAPPED)
            cmd->rxQueueNum = wmip->wmi_trafficClassMap[DNLINK_TRAFFIC][params->trafficClass];
        else
            cmd->rxQueueNum = wmip->wmi_olderPriRxMbox;
    } else {
        cmd->rxQueueNum = params->rxQueueNum;
    }

    /* mike: should be SYNC_BEFORE_WMIFLAG */
    return (wmi_cmd_send(wmip, osbuf, WMI_CREATE_PSTREAM_CMDID,
                         NO_SYNC_WMIFLAG));
}

A_STATUS
wmi_delete_pstream_cmd(struct wmi_t *wmip, A_UINT8 txQueueNumber, A_UINT8 rxQueueNumber, A_UINT8 dir)
{
    void *osbuf;
    WMI_DELETE_PSTREAM_CMD *cmd;
    A_STATUS status;
    A_UINT8 class;

    osbuf = a_netbuf_alloc(sizeof(*cmd));
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    if (dir == BIDIR_TRAFFIC) {
        class = wmip->wmi_mboxMap[UPLINK_TRAFFIC][txQueueNumber].trafficClass;
        if (wmip->wmi_pstreamCmdInProgress[UPLINK_TRAFFIC][class]
         || wmip->wmi_pstreamCmdInProgress[DNLINK_TRAFFIC][class]) {
            return A_EBUSY;
        }
        wmip->wmi_pstreamCmdInProgress[UPLINK_TRAFFIC][class] = TRUE;
        wmip->wmi_pstreamCmdInProgress[DNLINK_TRAFFIC][class] = TRUE;
    } else {
        if (dir == UPLINK_TRAFFIC) {
            class = wmip->wmi_mboxMap[UPLINK_TRAFFIC][txQueueNumber].trafficClass;
        } else {
            class = wmip->wmi_mboxMap[DNLINK_TRAFFIC][rxQueueNumber].trafficClass;
        }
        if (wmip->wmi_pstreamCmdInProgress[dir][class]) {
            return A_EBUSY;
        }
        wmip->wmi_pstreamCmdInProgress[dir][class] = TRUE;
    }

    a_netbuf_put(osbuf, sizeof(*cmd));

    cmd = (WMI_DELETE_PSTREAM_CMD *)(a_netbuf_to_data(osbuf));
    A_MEMZERO(cmd, sizeof(*cmd));
    cmd->txQueueNumber = txQueueNumber;
    cmd->rxQueueNumber = rxQueueNumber;
    cmd->trafficDirection = dir;
    cmd->trafficClass = class;
    WMI_DEBUG_PRINTF("Sending delete_pstream_cmd: txQ=%d, rxQ=%d, dir=%d\n",
                     txQueueNumber, rxQueueNumber, dir);
    status = (wmi_cmd_send(wmip, osbuf, WMI_DELETE_PSTREAM_CMDID,
                         (dir == UPLINK_TRAFFIC || dir == BIDIR_TRAFFIC) ? SYNC_BEFORE_WMIFLAG : NO_SYNC_WMIFLAG));

    if (class != WMM_AC_BE) {
        /* Update internal states */
        if (dir == UPLINK_TRAFFIC || dir == BIDIR_TRAFFIC) {
            wmip->wmi_numQoSStream--;
            ar6000_set_numdataendpts(wmip->wmi_devt, wmip->wmi_numQoSStream+1);
            wmip->wmi_priority[wmip->wmi_mboxMap[UPLINK_TRAFFIC][txQueueNumber].priorityNum].inUse = 0;
            wmip->wmi_trafficClassMap[UPLINK_TRAFFIC][class] = WMI_NOT_MAPPED;
            wmip->wmi_mboxMap[UPLINK_TRAFFIC][txQueueNumber].priorityNum = WMI_NOT_MAPPED;
            wmip->wmi_mboxMap[UPLINK_TRAFFIC][txQueueNumber].trafficClass = WMM_AC_BE;
        }
    }

    return status;
}


/*
 * used to set the bit rate.  rate is in Kbps.  If rate == -1
 * then auto selection is used.
 */
A_STATUS
wmi_set_bitrate_cmd(struct wmi_t *wmip, A_INT32 rate)
{
    void *osbuf;
    WMI_BIT_RATE_CMD *cmd;
    A_INT8 index;

    index = wmi_validate_bitrate(wmip, rate);
    if(index == A_EINVAL){
      return A_EINVAL;
    }
    osbuf = a_netbuf_alloc(sizeof(*cmd));
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    a_netbuf_put(osbuf, sizeof(*cmd));

    cmd = (WMI_BIT_RATE_CMD *)(a_netbuf_to_data(osbuf));
    A_MEMZERO(cmd, sizeof(*cmd));

    cmd->rateIndex = index;

    return (wmi_cmd_send(wmip, osbuf, WMI_SET_BITRATE_CMDID, NO_SYNC_WMIFLAG));
}

A_STATUS
wmi_get_bitrate_cmd(struct wmi_t *wmip)
{
    void *osbuf;

    osbuf = a_netbuf_alloc(0);      /* no payload */
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    return (wmi_cmd_send(wmip, osbuf, WMI_GET_BITRATE_CMDID, NO_SYNC_WMIFLAG));
}

A_INT8
wmi_validate_bitrate(struct wmi_t *wmip, A_INT32 rate)
{
    A_INT8 i;
    if (rate != -1)
    {
        for (i=0;;i++)
        {
            if (wmi_rateTable[i] == 0) {
                return A_EINVAL;
            }
            if (wmi_rateTable[i] == rate) {
                break;
            }
        }
    }
    else{
     i = -1;
    }

    if (wmip->wmi_phyMode == WMI_11A_MODE &&
        (i < MODE_A_SUPPORT_RATE_START || i > MODE_A_SUPPORT_RATE_STOP))
    {
        return A_EINVAL;
    } else if (wmip->wmi_phyMode == WMI_11B_MODE &&
        (i < MODE_B_SUPPORT_RATE_START || i > MODE_B_SUPPORT_RATE_STOP))
    {
        return A_EINVAL;
    } else if (wmip->wmi_phyMode == WMI_11GONLY_MODE &&
        (i < MODE_GONLY_SUPPORT_RATE_START || i > MODE_GONLY_SUPPORT_RATE_STOP))
    {
        return A_EINVAL;
    }

    return i;
 }

A_STATUS
wmi_get_channelList_cmd(struct wmi_t *wmip)
{
    void *osbuf;

    osbuf = a_netbuf_alloc(0);      /* no payload */
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    return (wmi_cmd_send(wmip, osbuf, WMI_GET_CHANNEL_LIST_CMDID,
                         NO_SYNC_WMIFLAG));
}

/*
 * used to generate a wmi sey channel Parameters cmd.
 * mode should always be specified and corresponds to the phy mode of the
 * wlan.
 * numChan should alway sbe specified. If zero indicates that all available
 * channels should be used.
 * channelList is an array of channel frequencies (in Mhz) which the radio
 * should limit its operation to.  It should be NULL if numChan == 0.  Size of
 * array should correspond to numChan entries.
 */
A_STATUS
wmi_set_channelParams_cmd(struct wmi_t *wmip, WMI_PHY_MODE mode, A_INT8 numChan,
                          A_UINT16 *channelList)
{
    void *osbuf;
    WMI_CHANNEL_PARAMS_CMD *cmd;
    A_INT8 size;

    size = sizeof (*cmd);

    if (numChan) {
        if (numChan > WMI_MAX_CHANNELS) {
            return A_EINVAL;
        }
        size += sizeof(A_UINT16) * (numChan - 1);
    }

    osbuf = a_netbuf_alloc(size);
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    a_netbuf_put(osbuf, size);

    cmd = (WMI_CHANNEL_PARAMS_CMD *)(a_netbuf_to_data(osbuf));
    A_MEMZERO(cmd, size);

    wmip->wmi_phyMode = mode;
    cmd->phyMode     = mode;
    cmd->numChannels = numChan;
    A_MEMCPY(cmd->channelList, channelList, numChan * sizeof(A_UINT16));

    return (wmi_cmd_send(wmip, osbuf, WMI_SET_CHANNEL_PARAMS_CMDID,
                         NO_SYNC_WMIFLAG));
}

A_STATUS
wmi_set_link_threshold_params(struct wmi_t *wmip,
                                A_UINT8     highThreshold_upperVal,
                                A_UINT8     highThreshold_lowerVal,
                                A_UINT8     lowThreshold_upperVal,
                                A_UINT8     lowThreshold_lowerVal,
                                A_UINT32    pollTime)
{
    void    *osbuf;
    A_INT8  size;
    WMI_RSSI_THRESHOLD_PARAMS_CMD *cmd;

    /* These values are in ascending order */
    if( highThreshold_upperVal <= highThreshold_lowerVal ||
        lowThreshold_upperVal  <= lowThreshold_lowerVal  ||
        highThreshold_lowerVal <= lowThreshold_upperVal)
        return A_EINVAL;

    size = sizeof (*cmd);

    osbuf = a_netbuf_alloc(size);
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    a_netbuf_put(osbuf, size);

    cmd = (WMI_RSSI_THRESHOLD_PARAMS_CMD *)(a_netbuf_to_data(osbuf));
    A_MEMZERO(cmd, size);

    cmd->highThreshold_upperVal = highThreshold_upperVal;
    cmd->highThreshold_lowerVal = highThreshold_lowerVal;
    cmd->lowThreshold_upperVal  = lowThreshold_upperVal;
    cmd->lowThreshold_lowerVal  = lowThreshold_lowerVal;
    cmd->pollTime               = pollTime;

    return (wmi_cmd_send(wmip, osbuf, WMI_RSSI_THRESHOLD_PARAMS_CMDID,
                            NO_SYNC_WMIFLAG));
}


A_STATUS
wmi_set_error_report_bitmask(struct wmi_t *wmip, A_UINT32 mask)
{
    void    *osbuf;
    A_INT8  size;
    WMI_TARGET_ERROR_REPORT_BITMASK *cmd;

    size = sizeof (*cmd);

    osbuf = a_netbuf_alloc(size);
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    a_netbuf_put(osbuf, size);

    cmd = (WMI_TARGET_ERROR_REPORT_BITMASK *)(a_netbuf_to_data(osbuf));
    A_MEMZERO(cmd, size);

    cmd->bitmask = mask;

    return (wmi_cmd_send(wmip, osbuf, WMI_TARGET_ERROR_REPORT_BITMASK_CMDID,
                            NO_SYNC_WMIFLAG));
}


A_STATUS
wmi_get_stats_cmd(struct wmi_t *wmip)
{
    void *osbuf;

    osbuf = a_netbuf_alloc(0);      /* no payload */
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    return (wmi_cmd_send(wmip, osbuf, WMI_GET_STATISTICS_CMDID,
                         NO_SYNC_WMIFLAG));
}

A_STATUS
wmi_addBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex, A_UINT8 *bssid)
{
    void *osbuf;
    WMI_ADD_BAD_AP_CMD *cmd;

    if ((bssid == NULL) || (apIndex > WMI_MAX_BAD_AP_INDEX)) {
        return A_EINVAL;
    }

    osbuf = a_netbuf_alloc(sizeof(*cmd));
    if (osbuf == NULL) {
        return A_NO_MEMORY;
    }

    a_netbuf_put(osbuf, sizeof(*cmd));

    cmd = (WMI_ADD_BAD_AP_CMD *)(a_netbuf_to_data(osbuf));
    cmd->badApIndex = apIndex;
    A_MEMCPY(cmd->bssid, bssid, sizeof(cmd->bssid));

    return (wmi_cmd_send(wmip, osbuf, WMI_ADD_BAD_AP_CMDID, NO_SYNC_WMIFLAG));
}

A_STATUS
wmi_deleteBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex)
{
    void *osbuf;
    WMI_DELETE_BAD_AP_CMD *c