Root/drivers/staging/csr/csr_wifi_router_transport.c

1/** @file router_transport.c
2 *
3 *
4 * Copyright (C) Cambridge Silicon Radio Ltd 2006-2010. All rights reserved.
5 *
6 * Refer to LICENSE.txt included with this source code for details on
7 * the license terms.
8 *
9 ****************************************************************************/
10
11#include "unifi_priv.h"
12
13#include "csr_sched.h"
14#include "csr_msgconv.h"
15
16#include "sme_userspace.h"
17
18#include "csr_wifi_hostio_prim.h"
19#include "csr_wifi_router_lib.h"
20#include "csr_wifi_router_sef.h"
21#include "csr_wifi_router_converter_init.h"
22#include "csr_wifi_router_ctrl_lib.h"
23#include "csr_wifi_router_ctrl_sef.h"
24#include "csr_wifi_router_ctrl_converter_init.h"
25#include "csr_wifi_sme_prim.h"
26#include "csr_wifi_sme_sef.h"
27#include "csr_wifi_sme_converter_init.h"
28#ifdef CSR_SUPPORT_WEXT
29#ifdef CSR_SUPPORT_WEXT_AP
30#include "csr_wifi_nme_ap_prim.h"
31#include "csr_wifi_nme_ap_sef.h"
32#include "csr_wifi_nme_ap_converter_init.h"
33#endif
34#endif
35
36static unifi_priv_t *drvpriv = NULL;
37void CsrWifiRouterTransportInit(unifi_priv_t *priv)
38{
39    unifi_trace(priv, UDBG1, "CsrWifiRouterTransportInit: \n");
40
41    drvpriv = priv;
42    (void)CsrMsgConvInit();
43    CsrWifiRouterConverterInit();
44    CsrWifiRouterCtrlConverterInit();
45    CsrWifiSmeConverterInit();
46#ifdef CSR_SUPPORT_WEXT
47#ifdef CSR_SUPPORT_WEXT_AP
48    CsrWifiNmeApConverterInit();
49#endif
50#endif
51}
52
53void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, size_t bufferLength)
54{
55    CsrMsgConvMsgEntry* msgEntry;
56    u16 primType;
57    CsrSchedQid src;
58    CsrSchedQid dest;
59    u16 msgType;
60    size_t offset = 0;
61    CsrWifiFsmEvent* msg;
62
63    /* Decode the prim and message type */
64    CsrUint16Des(&primType, buffer, &offset);
65    CsrUint16Des(&src, buffer, &offset);
66    CsrUint16Des(&dest, buffer, &offset);
67    CsrUint16Des(&msgType, buffer, &offset);
68    offset -= 2; /* Adjust as the Deserialise Function will read this as well */
69
70    unifi_trace(priv, UDBG4, "CsrWifiRouterTransportRecv: primType=0x%.4X, msgType=0x%.4X, bufferLength=%d\n",
71                primType, msgType, bufferLength);
72
73    /* Special handling for HOSTIO messages.... */
74    if (primType == CSR_WIFI_HOSTIO_PRIM)
75    {
76        CsrWifiRouterCtrlHipReq req = {{CSR_WIFI_ROUTER_CTRL_HIP_REQ, CSR_WIFI_ROUTER_CTRL_PRIM, dest, src, NULL}, 0, NULL, 0, NULL, 0, NULL};
77
78        req.mlmeCommandLength = bufferLength;
79        req.mlmeCommand = buffer;
80
81        offset += 8;/* Skip the id, src, dest and slot number */
82        CsrUint16Des(&req.dataRef1Length, buffer, &offset);
83        offset += 2; /* Skip the slot number */
84        CsrUint16Des(&req.dataRef2Length, buffer, &offset);
85
86        if (req.dataRef1Length)
87        {
88            u16 dr1Offset = (bufferLength - req.dataRef2Length) - req.dataRef1Length;
89            req.dataRef1 = &buffer[dr1Offset];
90        }
91
92        if (req.dataRef2Length)
93        {
94            u16 dr2Offset = bufferLength - req.dataRef2Length;
95            req.dataRef2 = &buffer[dr2Offset];
96        }
97
98        /* Copy the hip data but strip off the prim type */
99        req.mlmeCommandLength -= (req.dataRef1Length + req.dataRef2Length + 6);
100        req.mlmeCommand = &buffer[6];
101
102        CsrWifiRouterCtrlHipReqHandler(priv, &req.common);
103        return;
104    }
105
106    msgEntry = CsrMsgConvFindEntry(primType, msgType);
107    if (!msgEntry)
108    {
109        unifi_error(priv, "CsrWifiRouterTransportDeserialiseAndSend can not process the message. primType=0x%.4X, msgType=0x%.4X\n",
110                    primType, msgType);
111        dump(buffer, bufferLength);
112        return;
113    }
114
115    msg = (CsrWifiFsmEvent*)(msgEntry->deserFunc)(&buffer[offset], bufferLength - offset);
116
117    msg->primtype = primType;
118    msg->type = msgType;
119    msg->source = src;
120    msg->destination = dest;
121
122    switch(primType)
123    {
124    case CSR_WIFI_ROUTER_CTRL_PRIM:
125        CsrWifiRouterCtrlDownstreamStateHandlers[msg->type - CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST](priv, msg);
126        CsrWifiRouterCtrlFreeDownstreamMessageContents(CSR_WIFI_ROUTER_CTRL_PRIM, msg);
127        break;
128    case CSR_WIFI_ROUTER_PRIM:
129        CsrWifiRouterDownstreamStateHandlers[msg->type - CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST](priv, msg);
130        CsrWifiRouterFreeDownstreamMessageContents(CSR_WIFI_ROUTER_PRIM, msg);
131        break;
132        case CSR_WIFI_SME_PRIM:
133            CsrWifiSmeUpstreamStateHandlers[msg->type - CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST](priv, msg);
134            CsrWifiSmeFreeUpstreamMessageContents(CSR_WIFI_SME_PRIM, msg);
135            break;
136#ifdef CSR_SUPPORT_WEXT
137#ifdef CSR_SUPPORT_WEXT_AP
138        case CSR_WIFI_NME_AP_PRIM:
139            CsrWifiNmeApUpstreamStateHandlers(priv, msg);
140            CsrWifiNmeApFreeUpstreamMessageContents(CSR_WIFI_NME_AP_PRIM, msg);
141            break;
142#endif
143#endif
144        default:
145            unifi_error(priv, "CsrWifiRouterTransportDeserialiseAndSend unhandled prim type 0x%.4X\n", primType);
146            break;
147    }
148    kfree(msg);
149}
150
151static void CsrWifiRouterTransportSerialiseAndSend(u16 primType, void* msg)
152{
153    CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)msg;
154    CsrMsgConvMsgEntry* msgEntry;
155    size_t msgSize;
156    size_t encodeBufferLen = 0;
157    size_t offset = 0;
158    u8* encodeBuffer;
159
160    unifi_trace(drvpriv, UDBG4, "CsrWifiRouterTransportSerialiseAndSend: primType=0x%.4X, msgType=0x%.4X\n",
161                primType, evt->type);
162
163    msgEntry = CsrMsgConvFindEntry(primType, evt->type);
164    if (!msgEntry)
165    {
166        unifi_error(drvpriv, "CsrWifiRouterTransportSerialiseAndSend can not process the message. primType=0x%.4X, msgType=0x%.4X\n",
167                    primType, evt->type);
168        return;
169    }
170
171    msgSize = 6 + (msgEntry->sizeofFunc)((void*)msg);
172
173    encodeBuffer = kmalloc(msgSize, GFP_KERNEL);
174
175    /* Encode PrimType */
176    CsrUint16Ser(encodeBuffer, &encodeBufferLen, primType);
177    CsrUint16Ser(encodeBuffer, &encodeBufferLen, evt->source);
178    CsrUint16Ser(encodeBuffer, &encodeBufferLen, evt->destination);
179
180    (void)(msgEntry->serFunc)(&encodeBuffer[encodeBufferLen], &offset, msg);
181    encodeBufferLen += offset;
182
183    uf_sme_queue_message(drvpriv, encodeBuffer, encodeBufferLen);
184
185    /* Do not use msgEntry->freeFunc because the memory is owned by the driver */
186    kfree(msg);
187}
188
189#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
190void CsrSchedMessagePutStringLog(CsrSchedQid q, u16 mi, void *mv, u32 line, char *file)
191#else
192void CsrSchedMessagePut(CsrSchedQid q, u16 mi, void *mv)
193#endif
194{
195    CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)mv;
196    evt->destination = q;
197    CsrWifiRouterTransportSerialiseAndSend(mi, mv);
198}
199
200

Archive Download this file



interactive