drivers/staging/csr/csr_wifi_serialize_primitive_types.c

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2011
   4             All rights reserved and confidential information of CSR
   5
   6             Refer to LICENSE.txt included with this source for details
   7             on the license terms.
   8
   9 *****************************************************************************/
  10
  11 #include <linux/module.h>
  12 #include "csr_types.h"
  13 #include "csr_pmem.h"
  14 #include "csr_util.h"
  15 #include "csr_msgconv.h"
  16 #include "csr_wifi_msgconv.h"
  17 #include "csr_wifi_lib.h"
  18
  19 void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
  20 {
  21     CsrUint32 val;
  22
  23     val = ((buffer[(*offset) + 2] << 16) |
  24            (buffer[(*offset) + 1] << 8) |
  25            (buffer[(*offset)]));
  26
  27     *offset += 3;
  28     *v = val;
  29 }
  30
  31
  32 /* Big endian :e.g WSC, TCLAS */
  33 void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset)
  34 {
  35     CsrUint16 val;
  36
  37     val = (buffer[(*offset)] << 8) | (buffer[(*offset) + 1]);
  38     *offset += 2;
  39
  40     *v = val;
  41 }
  42
  43
  44 void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
  45 {
  46     CsrUint32 val;
  47
  48     val = ((buffer[(*offset)] << 16) |
  49            (buffer[(*offset) + 1] << 8) |
  50            (buffer[(*offset) + 2]));
  51
  52     *offset += 3;
  53     *v = val;
  54 }
  55
  56
  57 void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
  58 {
  59     CsrUint32 val;
  60
  61     val = ((buffer[(*offset)] << 24) |
  62            (buffer[(*offset) + 1] << 16) |
  63            (buffer[(*offset) + 2] << 8) |
  64            (buffer[(*offset) + 3]));
  65
  66     *offset += 4;
  67     *v = val;
  68 }
  69
  70
  71 void CsrUint24Ser(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
  72 {
  73     ptr[(*len) + 2] = (CsrUint8)((v & 0x00ff0000) >> 16);
  74     ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
  75     ptr[(*len)]     = (CsrUint8)((v & 0x000000ff));
  76
  77     *len += 3;
  78 }
  79
  80
  81 /* Big endian :e.g WSC, TCLAS */
  82 void CsrUint16SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint16 v)
  83 {
  84     ptr[(*len)] = (CsrUint8)((v & 0xff00) >> 8);
  85     ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff));
  86
  87     *len += 2;
  88 }
  89
  90
  91 void CsrUint32SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
  92 {
  93     ptr[(*len)] = (CsrUint8)((v & 0xff000000) >> 24);
  94     ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff0000) >> 16);
  95     ptr[(*len) + 2] = (CsrUint8)((v & 0x0000ff00) >> 8);
  96     ptr[(*len) + 3] = (CsrUint8)((v & 0x000000ff));
  97
  98     *len += 4;
  99 }
 100
 101
 102 void CsrUint24SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
 103 {
 104     ptr[(*len)] = (CsrUint8)((v & 0x00ff0000) >> 16);
 105     ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
 106     ptr[(*len) + 2] = (CsrUint8)((v & 0x000000ff));
 107
 108     *len += 3;
 109 }
 110
 111
 112 CsrSize CsrWifiEventSizeof(void *msg)
 113 {
 114     return 2;
 115 }
 116 EXPORT_SYMBOL_GPL(CsrWifiEventSizeof);
 117
 118 CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 119 {
 120     CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *)msg;
 121     *len = 0;
 122     CsrUint16Ser(ptr, len, primitive->type);
 123     return(ptr);
 124 }
 125 EXPORT_SYMBOL_GPL(CsrWifiEventSer);
 126
 127 void* CsrWifiEventDes(CsrUint8 *buffer, CsrSize length)
 128 {
 129     CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *) CsrPmemAlloc(sizeof(CsrWifiFsmEvent));
 130     CsrSize offset = 0;
 131     CsrUint16Des(&primitive->type, buffer, &offset);
 132
 133     return primitive;
 134 }
 135 EXPORT_SYMBOL_GPL(CsrWifiEventDes);
 136
 137 CsrSize CsrWifiEventCsrUint8Sizeof(void *msg)
 138 {
 139     return 3;
 140 }
 141 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Sizeof);
 142
 143 CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
 144 {
 145     CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *)msg;
 146     *len = 0;
 147     CsrUint16Ser(ptr, len, primitive->common.type);
 148     CsrUint8Ser(ptr, len, primitive->value);
 149     return(ptr);
 150 }
 151 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Ser);
 152
 153
 154 void* CsrWifiEventCsrUint8Des(CsrUint8 *buffer, CsrSize length)
 155 {
 156     CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint8));
 157
 158     CsrSize offset = 0;
 159     CsrUint16Des(&primitive->common.type, buffer, &offset);
 160     CsrUint8Des(&primitive->value, buffer, &offset);
 161
 162     return primitive;
 163 }
 164 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Des);
 165
 166
 167 CsrSize CsrWifiEventCsrUint16Sizeof(void *msg)
 168 {
 169     return 4;
 170 }
 171 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Sizeof);
 172
 173
 174 CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
 175 {
 176     CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *)msg;
 177     *len = 0;
 178     CsrUint16Ser(ptr, len, primitive->common.type);
 179     CsrUint16Ser(ptr, len, primitive->value);
 180     return(ptr);
 181 }
 182 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Ser);
 183
 184 void* CsrWifiEventCsrUint16Des(CsrUint8 *buffer, CsrSize length)
 185 {
 186     CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16));
 187
 188     CsrSize offset = 0;
 189     CsrUint16Des(&primitive->common.type, buffer, &offset);
 190     CsrUint16Des(&primitive->value, buffer, &offset);
 191
 192     return primitive;
 193 }
 194 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Des);
 195
 196
 197 CsrSize CsrWifiEventCsrUint32Sizeof(void *msg)
 198 {
 199     return 6;
 200 }
 201 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Sizeof);
 202
 203 CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
 204 {
 205     CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *)msg;
 206     *len = 0;
 207     CsrUint16Ser(ptr, len, primitive->common.type);
 208     CsrUint32Ser(ptr, len, primitive->value);
 209     return(ptr);
 210 }
 211 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Ser);
 212
 213
 214 void* CsrWifiEventCsrUint32Des(CsrUint8 *buffer, CsrSize length)
 215 {
 216     CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint32));
 217
 218     CsrSize offset = 0;
 219     CsrUint16Des(&primitive->common.type, buffer, &offset);
 220     CsrUint32Des(&primitive->value, buffer, &offset);
 221
 222     return primitive;
 223 }
 224 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Des);
 225
 226 CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg)
 227 {
 228     return 5;
 229 }
 230 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Sizeof);
 231
 232 CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
 233 {
 234     CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *)msg;
 235     *len = 0;
 236     CsrUint16Ser(ptr, len, primitive->common.type);
 237     CsrUint16Ser(ptr, len, primitive->value16);
 238     CsrUint8Ser(ptr, len, primitive->value8);
 239     return(ptr);
 240 }
 241 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Ser);
 242
 243
 244 void* CsrWifiEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length)
 245 {
 246     CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16CsrUint8));
 247
 248     CsrSize offset = 0;
 249     CsrUint16Des(&primitive->common.type, buffer, &offset);
 250     CsrUint16Des(&primitive->value16, buffer, &offset);
 251     CsrUint8Des(&primitive->value8, buffer, &offset);
 252
 253     return primitive;
 254 }
 255 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Des);
 256
 257