aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/staging/csr/csr_msgconv.c32
-rw-r--r--drivers/staging/csr/csr_msgconv.h59
-rw-r--r--drivers/staging/csr/csr_serialize_primitive_types.c398
-rw-r--r--drivers/staging/csr/csr_time.c27
-rw-r--r--drivers/staging/csr/csr_time.h91
-rw-r--r--drivers/staging/csr/csr_wifi_router_transport.c10
6 files changed, 1 insertions, 616 deletions
diff --git a/drivers/staging/csr/csr_msgconv.c b/drivers/staging/csr/csr_msgconv.c
index 69ae790945bd..0081a255e91c 100644
--- a/drivers/staging/csr/csr_msgconv.c
+++ b/drivers/staging/csr/csr_msgconv.c
@@ -290,35 +290,3 @@ CsrMsgConvEntry *CsrMsgConvInit(void)
290 return converter; 290 return converter;
291} 291}
292EXPORT_SYMBOL_GPL(CsrMsgConvInit); 292EXPORT_SYMBOL_GPL(CsrMsgConvInit);
293
294CsrMsgConvEntry *CsrMsgConvGet(void)
295{
296 return converter;
297}
298
299#ifdef ENABLE_SHUTDOWN
300void CsrMsgConvDeinit(void)
301{
302 CsrMsgConvPrimEntry *s;
303
304 if (converter == NULL)
305 {
306 return;
307 }
308
309 /* Walk converter list and free elements. */
310 s = converter->profile_converters;
311 while (s)
312 {
313 CsrMsgConvPrimEntry *s_next;
314 s_next = s->next;
315 kfree(s);
316 s = s_next;
317 }
318
319 kfree(converter);
320 converter = NULL;
321}
322EXPORT_SYMBOL_GPL(CsrMsgConvDeinit);
323
324#endif /* ENABLE_SHUTDOWN */
diff --git a/drivers/staging/csr/csr_msgconv.h b/drivers/staging/csr/csr_msgconv.h
index 08497096fdfe..09489f38e52d 100644
--- a/drivers/staging/csr/csr_msgconv.h
+++ b/drivers/staging/csr/csr_msgconv.h
@@ -64,17 +64,7 @@ void CsrMsgConvInsert(u16 primType, const CsrMsgConvMsgEntry *ce);
64CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType); 64CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType);
65CsrMsgConvMsgEntry *CsrMsgConvFindEntry(u16 primType, u16 msgType); 65CsrMsgConvMsgEntry *CsrMsgConvFindEntry(u16 primType, u16 msgType);
66CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(u16 primType, const void *msg); 66CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(u16 primType, const void *msg);
67CsrMsgConvEntry *CsrMsgConvGet(void);
68CsrMsgConvEntry *CsrMsgConvInit(void); 67CsrMsgConvEntry *CsrMsgConvInit(void);
69#ifdef ENABLE_SHUTDOWN
70void CsrMsgConvDeinit(void);
71#endif /* ENABLE_SHUTDOWN */
72
73/* SHOULD BE INTERNAL TO FRAMEWORK AKA DEPRECATED */
74
75u32 CsrCharStringSerLen(const char *str);
76u32 CsrUtf8StringSerLen(const u8 *str);
77u32 CsrUtf16StringSerLen(const u16 *str);
78 68
79/* Prototypes for primitive type serializers */ 69/* Prototypes for primitive type serializers */
80void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value); 70void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value);
@@ -82,60 +72,13 @@ void CsrUint16Ser(u8 *buffer, size_t *offset, u16 value);
82void CsrUint32Ser(u8 *buffer, size_t *offset, u32 value); 72void CsrUint32Ser(u8 *buffer, size_t *offset, u32 value);
83void CsrMemCpySer(u8 *buffer, size_t *offset, const void *value, size_t length); 73void CsrMemCpySer(u8 *buffer, size_t *offset, const void *value, size_t length);
84void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value); 74void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value);
85void CsrUtf8StringSer(u8 *buffer, size_t *offset, const u8 *value);
86void CsrUtf16StringSer(u8 *buffer, size_t *offset, const u16 *value);
87void CsrVoidPtrSer(u8 *buffer, size_t *offset, void *ptr);
88void CsrSizeSer(u8 *buffer, size_t *offset, size_t value);
89 75
90void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset); 76void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset);
91void CsrUint16Des(u16 *value, u8 *buffer, size_t *offset); 77void CsrUint16Des(u16 *value, u8 *buffer, size_t *offset);
92void CsrUint32Des(u32 *value, u8 *buffer, size_t *offset); 78void CsrUint32Des(u32 *value, u8 *buffer, size_t *offset);
93void CsrMemCpyDes(void *value, u8 *buffer, size_t *offset, size_t length); 79void CsrMemCpyDes(void *value, u8 *buffer, size_t *offset, size_t length);
94void CsrCharStringDes(char **value, u8 *buffer, size_t *offset); 80void CsrCharStringDes(char **value, u8 *buffer, size_t *offset);
95void CsrUtf8StringDes(u8 **value, u8 *buffer, size_t *offset); 81
96void CsrUtf16StringDes(u16 **value, u8 *buffer, size_t *offset);
97void CsrVoidPtrDes(void **value, u8 *buffer, size_t *offset);
98void CsrSizeDes(size_t *value, u8 *buffer, size_t *offset);
99
100size_t CsrEventSizeof(void *msg);
101u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg);
102void *CsrEventDes(u8 *buffer, size_t length);
103
104size_t CsrEventCsrUint8Sizeof(void *msg);
105u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg);
106void *CsrEventCsrUint8Des(u8 *buffer, size_t length);
107
108size_t CsrEventCsrUint16Sizeof(void *msg);
109u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg);
110void *CsrEventCsrUint16Des(u8 *buffer, size_t length);
111
112size_t CsrEventCsrUint32Sizeof(void *msg);
113u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg);
114void *CsrEventCsrUint32Des(u8 *buffer, size_t length);
115
116size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg);
117u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg);
118void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length);
119
120size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg);
121u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
122void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length);
123
124size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg);
125u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg);
126void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length);
127
128size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg);
129u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
130void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length);
131
132size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg);
133u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
134void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length);
135
136size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg);
137u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
138void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length);
139 82
140#ifdef __cplusplus 83#ifdef __cplusplus
141} 84}
diff --git a/drivers/staging/csr/csr_serialize_primitive_types.c b/drivers/staging/csr/csr_serialize_primitive_types.c
index a6f29ea36d20..bf5e4ab9f959 100644
--- a/drivers/staging/csr/csr_serialize_primitive_types.c
+++ b/drivers/staging/csr/csr_serialize_primitive_types.c
@@ -15,34 +15,6 @@
15#include "csr_macro.h" 15#include "csr_macro.h"
16#include "csr_lib.h" 16#include "csr_lib.h"
17 17
18/********************************************************************************
19*
20* Name: CsrUtf16StrLen
21*
22* Description: The function returns the number of 16 bit elements present
23* in the 0-terminated string.
24*
25* Input: 0-terminated string of 16 bit unicoded characters.
26*
27* Output: The number of 16 bit elements in the string.
28*
29*********************************************************************************/
30static u32 CsrUtf16StrLen(const u16 *unicodeString)
31{
32 u32 length;
33
34 length = 0;
35 if (unicodeString != NULL)
36 {
37 while (*unicodeString)
38 {
39 length++;
40 unicodeString++;
41 }
42 }
43 return length;
44}
45
46void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset) 18void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset)
47{ 19{
48 *value = buffer[*offset]; 20 *value = buffer[*offset];
@@ -82,39 +54,6 @@ void CsrCharStringDes(char **value, u8 *buffer, size_t *offset)
82} 54}
83EXPORT_SYMBOL_GPL(CsrCharStringDes); 55EXPORT_SYMBOL_GPL(CsrCharStringDes);
84 56
85void CsrUtf8StringDes(u8 **value, u8 *buffer, size_t *offset)
86{
87 *value = (u8 *)kstrdup((char *) &buffer[*offset], GFP_KERNEL);
88 *offset += strlen((char *) *value) + 1;
89}
90
91void CsrUtf16StringDes(u16 **value, u8 *buffer, size_t *offset)
92{
93 u32 length, i;
94
95 CsrUint32Des(&length, buffer, offset);
96
97 *value = kmalloc(length * sizeof(**value), GFP_KERNEL);
98 for (i = 0; i < length; i++)
99 {
100 CsrUint16Des(&(*value)[i], buffer, offset);
101 }
102}
103
104void CsrSizeDes(size_t *value, u8 *buffer, size_t *offset)
105{
106 *value = (buffer[*offset + 0] << 0) |
107 (buffer[*offset + 1] << 8) |
108 (buffer[*offset + 2] << 16) |
109 (buffer[*offset + 3] << 24);
110 *offset += sizeof(*value);
111}
112
113void CsrVoidPtrDes(void **value, u8 *buffer, size_t *offset)
114{
115 CsrSizeDes((size_t *) value, buffer, offset);
116}
117
118void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value) 57void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value)
119{ 58{
120 buffer[*offset] = value; 59 buffer[*offset] = value;
@@ -160,340 +99,3 @@ void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value)
160 } 99 }
161} 100}
162EXPORT_SYMBOL_GPL(CsrCharStringSer); 101EXPORT_SYMBOL_GPL(CsrCharStringSer);
163
164void CsrUtf8StringSer(u8 *buffer, size_t *offset, const u8 *value)
165{
166 CsrCharStringSer(buffer, offset, (char *) value);
167}
168
169void CsrUtf16StringSer(u8 *buffer, size_t *offset, const u16 *value)
170{
171 if (value)
172 {
173 u32 length = CsrUtf16StrLen(value) + 1;
174 u32 i;
175
176 CsrUint32Ser(buffer, offset, length);
177
178 for (i = 0; i < length; i++)
179 {
180 CsrUint16Ser(buffer, offset, (u16) value[i]);
181 }
182 }
183 else
184 {
185 CsrUint32Ser(buffer, offset, 0);
186 }
187}
188
189void CsrSizeSer(u8 *buffer, size_t *offset, size_t value)
190{
191 buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
192 buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
193 buffer[*offset + 2] = (u8) ((value >> 16) & 0xFF);
194 buffer[*offset + 3] = (u8) ((value >> 24) & 0xFF);
195 *offset += sizeof(value);
196}
197
198void CsrVoidPtrSer(u8 *buffer, size_t *offset, void *ptr)
199{
200 CsrSizeSer(buffer, offset, (size_t) ptr);
201}
202
203u32 CsrCharStringSerLen(const char *str)
204{
205 if (str)
206 {
207 return (u32)(strlen(str) + sizeof(*str));
208 }
209 else
210 {
211 return sizeof(*str);
212 }
213}
214
215u32 CsrUtf8StringSerLen(const u8 *str)
216{
217 if (str)
218 {
219 return (u32)(strlen((char *) str) + sizeof(*str));
220 }
221 else
222 {
223 return sizeof(*str);
224 }
225}
226
227u32 CsrUtf16StringSerLen(const u16 *str)
228{
229 if (str)
230 {
231 /* We always write down the length of the string */
232 return sizeof(u32) + (CsrUtf16StrLen(str) + 1) * sizeof(*str);
233 }
234 else
235 {
236 return sizeof(u32);
237 }
238}
239
240size_t CsrEventSizeof(void *msg)
241{
242 return 2;
243}
244
245u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg)
246{
247 CsrEvent *primitive = (CsrEvent *) msg;
248 *len = 0;
249 CsrUint16Ser(ptr, len, primitive->type);
250 return ptr;
251}
252
253void *CsrEventDes(u8 *buffer, size_t length)
254{
255 CsrEvent *primitive = kmalloc(sizeof(CsrEvent), GFP_KERNEL);
256 size_t offset = 0;
257 CsrUint16Des(&primitive->type, buffer, &offset);
258
259 return primitive;
260}
261
262size_t CsrEventCsrUint8Sizeof(void *msg)
263{
264 return 3;
265}
266
267u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg)
268{
269 CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) msg;
270 *len = 0;
271 CsrUint16Ser(ptr, len, primitive->type);
272 CsrUint8Ser(ptr, len, primitive->value);
273 return ptr;
274}
275
276void *CsrEventCsrUint8Des(u8 *buffer, size_t length)
277{
278 CsrEventCsrUint8 *primitive = kmalloc(sizeof(CsrEventCsrUint8), GFP_KERNEL);
279
280 size_t offset = 0;
281 CsrUint16Des(&primitive->type, buffer, &offset);
282 CsrUint8Des(&primitive->value, buffer, &offset);
283
284 return primitive;
285}
286
287size_t CsrEventCsrUint16Sizeof(void *msg)
288{
289 return 4;
290}
291
292u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg)
293{
294 CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) msg;
295 *len = 0;
296 CsrUint16Ser(ptr, len, primitive->type);
297 CsrUint16Ser(ptr, len, primitive->value);
298 return ptr;
299}
300
301void *CsrEventCsrUint16Des(u8 *buffer, size_t length)
302{
303 CsrEventCsrUint16 *primitive = kmalloc(sizeof(CsrEventCsrUint16), GFP_KERNEL);
304
305 size_t offset = 0;
306 CsrUint16Des(&primitive->type, buffer, &offset);
307 CsrUint16Des(&primitive->value, buffer, &offset);
308
309 return primitive;
310}
311
312size_t CsrEventCsrUint32Sizeof(void *msg)
313{
314 return 6;
315}
316
317u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg)
318{
319 CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) msg;
320 *len = 0;
321 CsrUint16Ser(ptr, len, primitive->type);
322 CsrUint32Ser(ptr, len, primitive->value);
323 return ptr;
324}
325
326void *CsrEventCsrUint32Des(u8 *buffer, size_t length)
327{
328 CsrEventCsrUint32 *primitive = kmalloc(sizeof(CsrEventCsrUint32), GFP_KERNEL);
329
330 size_t offset = 0;
331 CsrUint16Des(&primitive->type, buffer, &offset);
332 CsrUint32Des(&primitive->value, buffer, &offset);
333
334 return primitive;
335}
336
337size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg)
338{
339 return 5;
340}
341
342u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg)
343{
344 CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) msg;
345 *len = 0;
346 CsrUint16Ser(ptr, len, primitive->type);
347 CsrUint16Ser(ptr, len, primitive->value1);
348 CsrUint8Ser(ptr, len, primitive->value2);
349 return ptr;
350}
351
352void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length)
353{
354 CsrEventCsrUint16CsrUint8 *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrUint8), GFP_KERNEL);
355
356 size_t offset = 0;
357 CsrUint16Des(&primitive->type, buffer, &offset);
358 CsrUint16Des(&primitive->value1, buffer, &offset);
359 CsrUint8Des(&primitive->value2, buffer, &offset);
360
361 return primitive;
362}
363
364size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg)
365{
366 return 6;
367}
368
369u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
370{
371 CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) msg;
372 *len = 0;
373 CsrUint16Ser(ptr, len, primitive->type);
374 CsrUint16Ser(ptr, len, primitive->value1);
375 CsrUint16Ser(ptr, len, primitive->value2);
376 return ptr;
377}
378
379void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length)
380{
381 CsrEventCsrUint16CsrUint16 *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrUint16), GFP_KERNEL);
382
383 size_t offset = 0;
384 CsrUint16Des(&primitive->type, buffer, &offset);
385 CsrUint16Des(&primitive->value1, buffer, &offset);
386 CsrUint16Des(&primitive->value2, buffer, &offset);
387
388 return primitive;
389}
390
391size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg)
392{
393 return 8;
394}
395
396u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg)
397{
398 CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) msg;
399 *len = 0;
400 CsrUint16Ser(ptr, len, primitive->type);
401 CsrUint16Ser(ptr, len, primitive->value1);
402 CsrUint32Ser(ptr, len, primitive->value2);
403 return ptr;
404}
405
406void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length)
407{
408 CsrEventCsrUint16CsrUint32 *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrUint32), GFP_KERNEL);
409
410 size_t offset = 0;
411 CsrUint16Des(&primitive->type, buffer, &offset);
412 CsrUint16Des(&primitive->value1, buffer, &offset);
413 CsrUint32Des(&primitive->value2, buffer, &offset);
414
415 return primitive;
416}
417
418size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg)
419{
420 CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
421 return 4 + strlen(primitive->value2) + 1;
422}
423
424u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
425{
426 CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
427 *len = 0;
428 CsrUint16Ser(ptr, len, primitive->type);
429 CsrUint16Ser(ptr, len, primitive->value1);
430 CsrCharStringSer(ptr, len, primitive->value2);
431 return ptr;
432}
433
434void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length)
435{
436 CsrEventCsrUint16CsrCharString *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrCharString), GFP_KERNEL);
437
438 size_t offset = 0;
439 CsrUint16Des(&primitive->type, buffer, &offset);
440 CsrUint16Des(&primitive->value1, buffer, &offset);
441 CsrCharStringDes(&primitive->value2, buffer, &offset);
442
443 return primitive;
444}
445
446size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg)
447{
448 return 8;
449}
450
451u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
452{
453 CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) msg;
454 *len = 0;
455 CsrUint16Ser(ptr, len, primitive->type);
456 CsrUint32Ser(ptr, len, primitive->value1);
457 CsrUint16Ser(ptr, len, primitive->value2);
458 return ptr;
459}
460
461void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length)
462{
463 CsrEventCsrUint32CsrUint16 *primitive = kmalloc(sizeof(CsrEventCsrUint32CsrUint16), GFP_KERNEL);
464
465 size_t offset = 0;
466 CsrUint16Des(&primitive->type, buffer, &offset);
467 CsrUint32Des(&primitive->value1, buffer, &offset);
468 CsrUint16Des(&primitive->value2, buffer, &offset);
469
470 return primitive;
471}
472
473size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg)
474{
475 CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
476 return 6 + strlen(primitive->value2) + 1;
477}
478
479u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
480{
481 CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
482 *len = 0;
483 CsrUint16Ser(ptr, len, primitive->type);
484 CsrUint32Ser(ptr, len, primitive->value1);
485 CsrCharStringSer(ptr, len, primitive->value2);
486 return ptr;
487}
488
489void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length)
490{
491 CsrEventCsrUint32CsrCharString *primitive = kmalloc(sizeof(CsrEventCsrUint32CsrCharString), GFP_KERNEL);
492
493 size_t offset = 0;
494 CsrUint16Des(&primitive->type, buffer, &offset);
495 CsrUint32Des(&primitive->value1, buffer, &offset);
496 CsrCharStringDes(&primitive->value2, buffer, &offset);
497
498 return primitive;
499}
diff --git a/drivers/staging/csr/csr_time.c b/drivers/staging/csr/csr_time.c
index 4d836749d6bd..83586ca34e8c 100644
--- a/drivers/staging/csr/csr_time.c
+++ b/drivers/staging/csr/csr_time.c
@@ -41,30 +41,3 @@ CsrTime CsrTimeGet(CsrTime *high)
41 return low; 41 return low;
42} 42}
43EXPORT_SYMBOL_GPL(CsrTimeGet); 43EXPORT_SYMBOL_GPL(CsrTimeGet);
44
45void CsrTimeUtcGet(CsrTimeUtc *tod, CsrTime *low, CsrTime *high)
46{
47 struct timespec ts;
48 u64 time;
49
50 ts = current_kernel_time();
51 time = (u64) ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
52
53 if (high != NULL)
54 {
55 *high = (CsrTime) ((time >> 32) & 0xFFFFFFFF);
56 }
57
58 if (low != NULL)
59 {
60 *low = (CsrTime) (time & 0xFFFFFFFF);
61 }
62
63 if (tod != NULL)
64 {
65 struct timeval tv;
66 do_gettimeofday(&tv);
67 tod->sec = tv.tv_sec;
68 tod->msec = tv.tv_usec / 1000;
69 }
70}
diff --git a/drivers/staging/csr/csr_time.h b/drivers/staging/csr/csr_time.h
index 09eeeee42e9f..2a45f3e4024d 100644
--- a/drivers/staging/csr/csr_time.h
+++ b/drivers/staging/csr/csr_time.h
@@ -75,32 +75,6 @@ typedef struct
75CsrTime CsrTimeGet(CsrTime *high); 75CsrTime CsrTimeGet(CsrTime *high);
76 76
77 77
78/*******************************************************************************
79
80 NAME
81 CsrTimeUtcGet
82
83 DESCRIPTION
84 Get the current system wallclock time, and optionally the current system
85 time in a low and a high part as would have been returned by
86 CsrTimeGet.
87
88 Although CsrTimeUtc is expressed in seconds and milliseconds, the actual
89 resolution is platform dependent, and can be less. It is recommended
90 that the resolution is at least 1 second.
91
92 PARAMETERS
93 tod - Pointer to variable that will receive the current system
94 wallclock time.
95 low - The low part of the current system time in microseconds. Passing
96 NULL is valid.
97 high - The high part of the current system time in microseconds. Passing
98 NULL is valid.
99
100*******************************************************************************/
101void CsrTimeUtcGet(CsrTimeUtc *tod, CsrTime *low, CsrTime *high);
102
103
104/*------------------------------------------------------------------*/ 78/*------------------------------------------------------------------*/
105/* CsrTime Macros */ 79/* CsrTime Macros */
106/*------------------------------------------------------------------*/ 80/*------------------------------------------------------------------*/
@@ -133,71 +107,6 @@ void CsrTimeUtcGet(CsrTimeUtc *tod, CsrTime *low, CsrTime *high);
133 *----------------------------------------------------------------------------*/ 107 *----------------------------------------------------------------------------*/
134#define CsrTimeSub(t1, t2) ((s32) (t1) - (s32) (t2)) 108#define CsrTimeSub(t1, t2) ((s32) (t1) - (s32) (t2))
135 109
136/*----------------------------------------------------------------------------*
137 * NAME
138 * CsrTimeEq
139 *
140 * DESCRIPTION
141 * Compare two time values.
142 *
143 * RETURNS
144 * !0 if "t1" equal "t2", else 0.
145 *
146 *----------------------------------------------------------------------------*/
147#define CsrTimeEq(t1, t2) ((t1) == (t2))
148
149/*----------------------------------------------------------------------------*
150 * NAME
151 * CsrTimeGt
152 *
153 * DESCRIPTION
154 * Compare two time values.
155 *
156 * RETURNS
157 * !0 if "t1" is greater than "t2", else 0.
158 *
159 *----------------------------------------------------------------------------*/
160#define CsrTimeGt(t1, t2) (CsrTimeSub((t1), (t2)) > 0)
161
162/*----------------------------------------------------------------------------*
163 * NAME
164 * CsrTimeGe
165 *
166 * DESCRIPTION
167 * Compare two time values.
168 *
169 * RETURNS
170 * !0 if "t1" is greater than, or equal to "t2", else 0.
171 *
172 *----------------------------------------------------------------------------*/
173#define CsrTimeGe(t1, t2) (CsrTimeSub((t1), (t2)) >= 0)
174
175/*----------------------------------------------------------------------------*
176 * NAME
177 * CsrTimeLt
178 *
179 * DESCRIPTION
180 * Compare two time values.
181 *
182 * RETURNS
183 * !0 if "t1" is less than "t2", else 0.
184 *
185 *----------------------------------------------------------------------------*/
186#define CsrTimeLt(t1, t2) (CsrTimeSub((t1), (t2)) < 0)
187
188/*----------------------------------------------------------------------------*
189 * NAME
190 * CsrTimeLe
191 *
192 * DESCRIPTION
193 * Compare two time values.
194 *
195 * RETURNS
196 * !0 if "t1" is less than, or equal to "t2", else 0.
197 *
198 *----------------------------------------------------------------------------*/
199#define CsrTimeLe(t1, t2) (CsrTimeSub((t1), (t2)) <= 0)
200
201#ifdef __cplusplus 110#ifdef __cplusplus
202} 111}
203#endif 112#endif
diff --git a/drivers/staging/csr/csr_wifi_router_transport.c b/drivers/staging/csr/csr_wifi_router_transport.c
index 4bff43547143..e905ead9389b 100644
--- a/drivers/staging/csr/csr_wifi_router_transport.c
+++ b/drivers/staging/csr/csr_wifi_router_transport.c
@@ -50,16 +50,6 @@ void CsrWifiRouterTransportInit(unifi_priv_t *priv)
50#endif 50#endif
51} 51}
52 52
53void CsrWifiRouterTransportDeinit(unifi_priv_t *priv)
54{
55 unifi_trace(priv, UDBG1, "CsrWifiRouterTransportDeinit: \n");
56 if (priv == drvpriv)
57 {
58 CsrMsgConvDeinit();
59 drvpriv = NULL;
60 }
61}
62
63void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, size_t bufferLength) 53void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, size_t bufferLength)
64{ 54{
65 CsrMsgConvMsgEntry* msgEntry; 55 CsrMsgConvMsgEntry* msgEntry;
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-11 14:47:10 -0400