1 /******************************************************************************
2 *
3 * Copyright(c) 2019 - 2020 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 #ifndef _PLTFM_OPS_NONE_H_
16 #define _PLTFM_OPS_NONE_H_
17 #include "phl_types.h"
18
_os_strpbrk(const char * cs,const char * ct)19 static char *_os_strpbrk(const char *cs, const char *ct)
20 {
21 const char *sc1, *sc2;
22
23 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
24 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
25 if (*sc1 == *sc2)
26 return (char *)sc1;
27 }
28 }
29 return NULL;
30 }
_os_strsep(char ** s,const char * ct)31 static __inline char *_os_strsep(char **s, const char *ct)
32 {
33 char *sbegin = *s;
34 char *end;
35
36 if (sbegin == NULL)
37 return NULL;
38
39 end = _os_strpbrk(sbegin, ct);
40 if (end)
41 *end++ = '\0';
42 *s = end;
43 return sbegin;
44 }
_os_sscanf(const char * buf,const char * fmt,...)45 static __inline int _os_sscanf(const char *buf, const char *fmt, ...)
46 {
47 return 0;
48 }
_os_strcmp(const char * s1,const char * s2)49 static __inline int _os_strcmp(const char *s1, const char *s2)
50 {
51 while (*s1 == *s2) {
52 if (*s1 == '\0')
53 break;
54 s1++;
55 s2++;
56 }
57 return *s1 - *s2;
58 }
_os_strncmp(const char * s1,const char * s2,size_t n)59 static __inline int _os_strncmp(const char *s1, const char *s2, size_t n)
60 {
61 if (n == 0)
62 return 0;
63 while (*s1 == *s2) {
64 if (*s1 == '\0')
65 break;
66 s1++;
67 s2++;
68 n--;
69 if (n == 0)
70 return 0;
71 }
72 return *s1 - *s2;
73 }
_os_strcpy(char * dest,const char * src)74 static __inline char *_os_strcpy(char *dest, const char *src)
75 {
76 return NULL;
77 }
_os_strncpy(char * dest,const char * src,size_t n)78 static inline char *_os_strncpy(char *dest, const char *src, size_t n)
79 {
80 return NULL;
81 }
_os_strchr(const char * s,int c)82 static __inline char *_os_strchr(const char *s, int c)
83 {
84 while (*s != (char)c)
85 if (*s++ == '\0')
86 return NULL;
87 return (char *)s;
88 }
_os_snprintf(char * str,size_t size,const char * format,...)89 static __inline int _os_snprintf(char *str, size_t size, const char *format, ...)
90 {
91 return 0;
92 }
93
_os_strncat(char * dest,char * src,size_t n)94 static __inline int _os_strncat(char *dest, char *src, size_t n)
95 {
96 return 0;
97 }
98
_os_strlen(u8 * buf)99 static __inline u32 _os_strlen(u8 *buf)
100 {
101 return 0;
102 }
_os_delay_ms(void * h,u32 ms)103 static __inline void _os_delay_ms(void *h, u32 ms)
104 {
105 }
_os_delay_us(void * h,u32 us)106 static __inline void _os_delay_us(void *h, u32 us)
107 {
108 }
_os_sleep_ms(void * h,u32 ms)109 static __inline void _os_sleep_ms(void *h, u32 ms)
110 {
111 }
_os_sleep_us(void * h,u32 us)112 static __inline void _os_sleep_us(void *h, u32 us)
113 {
114 }
_os_get_cur_time_us(void)115 static inline u32 _os_get_cur_time_us(void)
116 {
117 return 0;
118 }
_os_get_cur_time_ms(void)119 static inline u32 _os_get_cur_time_ms(void)
120 {
121 return (_os_get_cur_time_us() / 1000);
122 }
123
_os_modular64(u64 x,u64 y)124 static inline u64 _os_modular64(u64 x, u64 y)
125 {
126 return x % y;
127 }
_os_division64(u64 x,u64 y)128 static inline u64 _os_division64(u64 x, u64 y)
129 {
130 u32 low, low2, high, rem, result;
131
132 low = x & 0xFFFFFFFF;
133 high = x >> 32;
134 rem = high % (u32)y;
135 high= high / (u32)y;
136 low2 = low >> 16;
137 low2 += rem << 16;
138 rem = low2 % (u32)y;
139 low2 = low2 / (u32)y;
140 low = low & 0xFFFFFFFF;
141 low += rem << 16;
142 rem = low % (u32)y;
143 low = low / (u32)y;
144 result = low + ((u64)low2 << 16) + ((u64)high << 32);
145
146 return result;
147 }
148
_os_minus64(u64 x,u64 y)149 static inline u64 _os_minus64(u64 x, u64 y)
150
151 {
152 return x - y;
153 }
154
_os_add64(u64 x,u64 y)155 static inline u64 _os_add64(u64 x, u64 y)
156
157 {
158 return x + y;
159 }
160
_os_div_round_up(u32 x,u32 y)161 static inline u32 _os_div_round_up(u32 x, u32 y)
162 {
163 return (x + y - 1) / y;
164 }
165
166 #ifdef CONFIG_PCI_HCI
_os_cache_inv(void * d,_dma * bus_addr_l,_dma * bus_addr_h,u32 buf_sz,u8 direction)167 static inline void _os_cache_inv(void *d, _dma *bus_addr_l, _dma *bus_addr_h,
168 u32 buf_sz, u8 direction)
169 {
170 }
_os_cache_wback(void * d,_dma * bus_addr_l,_dma * bus_addr_h,u32 buf_sz,u8 direction)171 static inline void _os_cache_wback(void *d, _dma *bus_addr_l,
172 _dma *bus_addr_h, u32 buf_sz, u8 direction)
173 {
174 }
175
_os_dma_pool_create(void * d,char * name,u32 wd_page_sz)176 static inline void *_os_dma_pool_create(void *d, char *name, u32 wd_page_sz)
177 {
178 return NULL;
179 }
180
_os_dma_pool_destory(void * d,void * pool)181 static inline void _os_dma_pool_destory(void *d, void *pool)
182 {
183 }
184
185 /* txbd, rxbd, wd */
_os_shmem_alloc(void * d,void * pool,_dma * bus_addr_l,_dma * bus_addr_h,u32 buf_sz,u8 cache,u8 direction,void ** os_rsvd)186 static inline void *_os_shmem_alloc(void *d, void *pool, _dma *bus_addr_l,
187 _dma *bus_addr_h, u32 buf_sz,
188 u8 cache, u8 direction, void **os_rsvd)
189 {
190 return NULL;
191 }
_os_shmem_free(void * d,void * pool,u8 * vir_addr,_dma * bus_addr_l,_dma * bus_addr_h,u32 buf_sz,u8 cache,u8 direction,void * os_rsvd)192 static inline void _os_shmem_free(void *d, void *pool, u8 *vir_addr, _dma *bus_addr_l,
193 _dma *bus_addr_h, u32 buf_sz,
194 u8 cache, u8 direction, void *os_rsvd)
195 {
196 }
197 #endif /*CONFIG_PCI_HCI*/
198
_os_pkt_buf_unmap_rx(void * d,_dma bus_addr_l,_dma bus_addr_h,u32 buf_sz)199 static inline void *_os_pkt_buf_unmap_rx(void *d, _dma bus_addr_l, _dma bus_addr_h, u32 buf_sz)
200 {
201 return NULL;
202 }
203
_os_pkt_buf_map_rx(void * d,_dma * bus_addr_l,_dma * bus_addr_h,u32 buf_sz,void * os_priv)204 static inline void *_os_pkt_buf_map_rx(void *d, _dma *bus_addr_l, _dma *bus_addr_h,
205 u32 buf_sz, void *os_priv)
206 {
207 return NULL;
208 }
209
_os_pkt_buf_alloc_rx(void * d,_dma * bus_addr_l,_dma * bus_addr_h,u32 buf_sz,u8 cache,void ** os_priv)210 static inline void *_os_pkt_buf_alloc_rx(void *d, _dma *bus_addr_l,
211 _dma *bus_addr_h, u32 buf_sz, u8 cache, void **os_priv)
212 {
213 return NULL;
214 }
_os_pkt_buf_free_rx(void * d,u8 * vir_addr,_dma bus_addr_l,_dma bus_addr_h,u32 buf_sz,u8 cache,void * os_priv)215 static inline u8 *_os_pkt_buf_free_rx(void *d, u8 *vir_addr, _dma bus_addr_l,
216 _dma bus_addr_h, u32 buf_sz, u8 cache, void *os_priv)
217 {
218 return NULL;
219 }
220
221 /* phl pre-alloc network layer buffer */
_os_alloc_netbuf(void * d,u32 buf_sz,void ** os_priv)222 static inline void * _os_alloc_netbuf(void *d, u32 buf_sz, void **os_priv)
223 {
224 return NULL; // windows never do this.
225 }
226
227 /* Free netbuf for error case. (ex. drop rx-reorder packet) */
_os_free_netbuf(void * d,u8 * vir_addr,u32 buf_sz,void * os_priv)228 static inline void _os_free_netbuf(void *d, u8 *vir_addr, u32 buf_sz, void *os_priv)
229 {
230 }
_os_mem_alloc(void * h,u32 buf_sz)231 static __inline void *_os_mem_alloc(void *h, u32 buf_sz)
232 {
233 return NULL;
234 }
235
_os_mem_free(void * h,void * buf,u32 buf_sz)236 static __inline void _os_mem_free(void *h, void *buf, u32 buf_sz)
237 {
238 }
239 /*physically contiguous memory if the buffer will be accessed by a DMA device*/
_os_kmem_alloc(void * h,u32 buf_sz)240 static __inline void *_os_kmem_alloc(void *h, u32 buf_sz)
241 {
242 return NULL;
243 }
244
245 /*physically contiguous memory if the buffer will be accessed by a DMA device*/
_os_kmem_free(void * h,void * buf,u32 buf_sz)246 static __inline void _os_kmem_free(void *h, void *buf, u32 buf_sz)
247 {
248 }
_os_mem_set(void * h,void * buf,s8 value,u32 size)249 static __inline void _os_mem_set(void *h, void *buf, s8 value, u32 size)
250 {
251 }
_os_mem_cpy(void * h,void * dest,void * src,u32 size)252 static __inline void _os_mem_cpy(void *h, void *dest, void *src, u32 size)
253 {
254 }
_os_mem_cmp(void * h,void * ptr1,void * ptr2,u32 size)255 static __inline int _os_mem_cmp(void *h, void *ptr1, void *ptr2, u32 size)
256 {
257 return 0;
258 }
_os_init_timer(void * h,_os_timer * timer,void (* call_back_func)(void * context),void * context,const char * sz_id)259 static __inline void _os_init_timer(void *h, _os_timer *timer,
260 void (*call_back_func)(void *context), void *context,
261 const char *sz_id)
262 {
263 }
264
_os_set_timer(void * h,_os_timer * timer,u32 ms_delay)265 static __inline void _os_set_timer(void *h, _os_timer *timer, u32 ms_delay)
266 {
267 }
268
_os_cancel_timer(void * h,_os_timer * timer)269 static __inline void _os_cancel_timer(void *h, _os_timer *timer)
270 {
271 }
272
_os_cancel_timer_async(void * d,_os_timer * timer)273 static inline void _os_cancel_timer_async(void *d, _os_timer *timer)
274 {
275 }
276
_os_release_timer(void * h,_os_timer * timer)277 static __inline void _os_release_timer(void *h, _os_timer *timer)
278 {
279
280 }
_os_mutex_init(void * h,_os_mutex * mutex)281 static __inline void _os_mutex_init(void *h, _os_mutex *mutex)
282 {
283 }
284
_os_mutex_deinit(void * h,_os_mutex * mutex)285 static __inline void _os_mutex_deinit(void *h, _os_mutex *mutex)
286 {
287 }
288
_os_mutex_lock(void * h,_os_mutex * mutex)289 static __inline void _os_mutex_lock(void *h, _os_mutex *mutex)
290 {
291 }
292
_os_mutex_unlock(void * h,_os_mutex * mutex)293 static __inline void _os_mutex_unlock(void *h, _os_mutex *mutex)
294 {
295 }
296
_os_sema_init(void * d,_os_sema * sema,int int_cnt)297 static inline void _os_sema_init(void *d, _os_sema *sema, int int_cnt)
298 {
299 }
300
_os_sema_free(void * d,_os_sema * sema)301 static inline void _os_sema_free(void *d, _os_sema *sema)
302 {
303 }
304
_os_sema_up(void * d,_os_sema * sema)305 static inline void _os_sema_up(void *d, _os_sema *sema)
306 {
307 }
308
_os_sema_down(void * d,_os_sema * sema)309 static inline u8 _os_sema_down(void *d, _os_sema *sema)
310 {
311 return 0; //success
312 }
313
314 /* event */
_os_event_init(void * h,_os_event * event)315 static __inline void _os_event_init(void *h, _os_event *event)
316 {
317 }
_os_event_free(void * h,_os_event * event)318 static __inline void _os_event_free(void *h, _os_event *event)
319 {
320 }
_os_event_reset(void * h,_os_event * event)321 static __inline void _os_event_reset(void *h, _os_event *event)
322 {
323 }
324
_os_event_set(void * h,_os_event * event)325 static __inline void _os_event_set(void *h, _os_event *event)
326 {
327 }
328
329 /*
330 * m_sec
331 * == 0 : wait for completion
332 * > 0 : wait for timeout or completion
333 * return value
334 * 0:timeout
335 * otherwise:success
336 */
_os_event_wait(void * h,_os_event * event,u32 m_sec)337 static __inline int _os_event_wait(void *h, _os_event *event, u32 m_sec)
338 {
339 return 0;
340 }
341
342 /* spinlock */
_os_spinlock_init(void * d,_os_lock * plock)343 static __inline void _os_spinlock_init(void *d, _os_lock *plock)
344 {
345 }
_os_spinlock_free(void * d,_os_lock * plock)346 static __inline void _os_spinlock_free(void *d, _os_lock *plock)
347 {
348 }
349
_os_spinlock(void * d,_os_lock * plock,enum lock_type type,_os_spinlockfg * flags)350 static inline void _os_spinlock(void *d, _os_lock *plock,
351 enum lock_type type, _os_spinlockfg *flags)
352 {
353 }
_os_spinunlock(void * d,_os_lock * plock,enum lock_type type,_os_spinlockfg * flags)354 static inline void _os_spinunlock(void *d, _os_lock *plock,
355 enum lock_type type, _os_spinlockfg *flags)
356 {
357 }
_os_test_and_clear_bit(int nr,unsigned long * addr)358 static inline int _os_test_and_clear_bit(int nr, unsigned long *addr)
359 {
360 /*UNDO*/
361 return 0;
362 }
_os_test_and_set_bit(int nr,unsigned long * addr)363 static inline int _os_test_and_set_bit(int nr, unsigned long *addr)
364 {
365 /*UNDO*/
366 return 1;
367 }
368 /* Atomic integer operations */
_os_atomic_set(void * d,_os_atomic * v,int i)369 static __inline void _os_atomic_set(void *d, _os_atomic *v, int i)
370 {
371 }
372
_os_atomic_read(void * d,_os_atomic * v)373 static __inline int _os_atomic_read(void *d, _os_atomic *v)
374 {
375 return 0;
376 }
377
_os_atomic_add(void * d,_os_atomic * v,int i)378 static __inline void _os_atomic_add(void *d, _os_atomic *v, int i)
379 {
380 }
_os_atomic_sub(void * d,_os_atomic * v,int i)381 static __inline void _os_atomic_sub(void *d, _os_atomic *v, int i)
382 {
383 }
384
_os_atomic_inc(void * d,_os_atomic * v)385 static __inline void _os_atomic_inc(void *d, _os_atomic *v)
386 {
387 }
388
_os_atomic_dec(void * d,_os_atomic * v)389 static __inline void _os_atomic_dec(void *d, _os_atomic *v)
390 {
391 }
392
_os_atomic_add_return(void * d,_os_atomic * v,int i)393 static __inline int _os_atomic_add_return(void *d, _os_atomic *v, int i)
394 {
395 return 0;
396 }
397
_os_atomic_sub_return(void * d,_os_atomic * v,int i)398 static __inline int _os_atomic_sub_return(void *d, _os_atomic *v, int i)
399 {
400 return 0;
401 }
402
_os_atomic_inc_return(void * d,_os_atomic * v)403 static __inline int _os_atomic_inc_return(void *d, _os_atomic *v)
404 {
405 return 0;
406 }
407
_os_atomic_dec_return(void * d,_os_atomic * v)408 static __inline int _os_atomic_dec_return(void *d, _os_atomic *v)
409 {
410 return 0;
411 }
412 /*
413 static __inline bool _os_atomic_inc_unless(void *d, _os_atomic *v, int u)
414 {
415 return 0;
416 }
417 */
418
_os_tasklet_init(void * drv_priv,_os_tasklet * task,void (* call_back_func)(void * context),void * context)419 static inline enum rtw_phl_status _os_tasklet_init(void *drv_priv, _os_tasklet *task,
420 void (*call_back_func)(void* context), void *context)
421 {
422 return RTW_PHL_STATUS_SUCCESS;
423 }
424
_os_tasklet_deinit(void * drv_priv,_os_tasklet * task)425 static inline enum rtw_phl_status _os_tasklet_deinit(void *drv_priv, _os_tasklet *task)
426 {
427 return RTW_PHL_STATUS_SUCCESS;
428 }
429
_os_tasklet_schedule(void * drv_priv,_os_tasklet * task)430 static inline enum rtw_phl_status _os_tasklet_schedule(void *drv_priv, _os_tasklet *task)
431 {
432 return RTW_PHL_STATUS_SUCCESS;
433 }
434
_os_thread_init(void * drv_priv,_os_thread * thread,int (* call_back_func)(void * context),void * context,const char namefmt[])435 static __inline u8 _os_thread_init( void *drv_priv, _os_thread *thread,
436 int (*call_back_func)(void * context),
437 void *context,
438 const char namefmt[])
439 {
440 return RTW_PHL_STATUS_FAILURE;
441 }
_os_thread_deinit(void * drv_priv,_os_thread * thread)442 static __inline u8 _os_thread_deinit(void *drv_priv, _os_thread *thread)
443 {
444 return RTW_PHL_STATUS_FAILURE;
445 }
_os_thread_schedule(void * drv_priv,_os_thread * thread)446 static __inline enum rtw_phl_status _os_thread_schedule(void *drv_priv, _os_thread *thread)
447 {
448 return RTW_PHL_STATUS_FAILURE;
449 }
_os_thread_stop(void * drv_priv,_os_thread * thread)450 static inline void _os_thread_stop(void *drv_priv, _os_thread *thread)
451 {
452 }
_os_thread_check_stop(void * drv_priv,_os_thread * thread)453 static __inline int _os_thread_check_stop(void *drv_priv, _os_thread *thread)
454 {
455 return 1;
456 }
_os_thread_wait_stop(void * drv_priv,_os_thread * thread)457 static inline int _os_thread_wait_stop(void *drv_priv, _os_thread *thread)
458 {
459 return RTW_PHL_STATUS_SUCCESS;
460 }
461
462 #if 0
463 static inline _os_thread _os_thread_start(int (*threadfn)(void *data),
464 void *data, const char namefmt[])
465 {
466 return 0;
467 }
468 static inline bool _os_thread_stop(_os_thread th)
469 {
470 return 0;
471 }
472 static inline void _os_thread_wait_stop(void)
473 {
474 }
475 static inline int _os_thread_should_stop(void)
476 {
477 return 0;
478 }
479 #endif
480
_os_workitem_init(void * drv_priv,_os_workitem * workitem,void (* call_back_func)(void * context),void * context)481 static inline enum rtw_phl_status _os_workitem_init(void *drv_priv, _os_workitem *workitem,
482 void (*call_back_func)(void* context), void *context)
483 {
484 return RTW_PHL_STATUS_SUCCESS;
485 }
486
_os_workitem_schedule(void * drv_priv,_os_workitem * workitem)487 static inline enum rtw_phl_status _os_workitem_schedule(void *drv_priv, _os_workitem *workitem)
488 {
489 return RTW_PHL_STATUS_SUCCESS;
490 }
491
_os_workitem_deinit(void * drv_priv,_os_workitem * workitem)492 static inline enum rtw_phl_status _os_workitem_deinit(void *drv_priv, _os_workitem *workitem)
493 {
494 return RTW_PHL_STATUS_SUCCESS;
495 }
496
497 /*
498 * _os_read_file - phl read file api
499 * @path: path of the file to open and read
500 * @buf: the address of allocated buffer to store the file content
501 * @sz: the bytes to read at most
502 *
503 * returns bytes read
504 */
_os_read_file(const char * path,u8 * buf,u32 sz)505 static inline u32 _os_read_file(const char *path, u8 *buf, u32 sz)
506 {
507 /* OS Dependent API */
508 return 0;
509 }
510
511 #ifdef CONFIG_PCI_HCI
_os_read8_pcie(void * h,u32 addr)512 static __inline u8 _os_read8_pcie(void *h, u32 addr)
513 {
514 return 0;
515 }
_os_read16_pcie(void * h,u32 addr)516 static __inline u16 _os_read16_pcie(void *h, u32 addr)
517 {
518 return 0;
519
520 }
_os_read32_pcie(void * h,u32 addr)521 static __inline u32 _os_read32_pcie(void *h, u32 addr)
522 {
523 return 0;
524 }
525
_os_write8_pcie(void * h,u32 addr,u8 val)526 static __inline u32 _os_write8_pcie(void *h, u32 addr, u8 val)
527 {
528 return 0;
529 }
_os_write16_pcie(void * h,u32 addr,u16 val)530 static __inline u32 _os_write16_pcie(void *h, u32 addr, u16 val)
531 {
532 return 0;
533 }
_os_write32_pcie(void * h,u32 addr,u32 val)534 static __inline u32 _os_write32_pcie(void *h, u32 addr, u32 val)
535 {
536 return 0;
537 }
538 #endif/*#ifdef CONFIG_PCI_HCI*/
539
540 #ifdef CONFIG_USB_HCI
_os_usbctrl_vendorreq(void * h,u8 request,u16 value,u16 index,void * pdata,u16 len,u8 requesttype)541 static __inline u32 _os_usbctrl_vendorreq(void *h, u8 request, u16 value,
542 u16 index, void *pdata, u16 len, u8 requesttype)
543 {
544 return 0;
545 }
546
os_usb_tx(void * h,u8 * tx_buf_ptr,u8 bulk_id,u32 len,u8 * pkt_data_buf)547 static inline int os_usb_tx(void *h, u8 *tx_buf_ptr,
548 u8 bulk_id, u32 len, u8 *pkt_data_buf)
549 {
550 return 1;
551 }
552
os_enable_usb_out_pipes(void * drv_priv)553 static __inline void os_enable_usb_out_pipes(void *drv_priv)
554 {
555 }
556
os_disable_usb_out_pipes(void * drv_priv)557 static __inline void os_disable_usb_out_pipes(void *drv_priv)
558 {
559 /* Free bulkout urb */
560 }
561
os_out_token_alloc(void * drv_priv)562 static __inline u8 os_out_token_alloc(void *drv_priv)
563 {
564 return 0; // RTW_PHL_STATUS_SUCCESS
565 }
566
os_out_token_free(void * drv_priv)567 static __inline void os_out_token_free(void *drv_priv)
568 {
569 }
570
571
os_in_token_alloc(void * drv_priv)572 static __inline u8 os_in_token_alloc(void *drv_priv)
573 {
574 // Allocate in token (pUrb) list
575 return 0;
576 }
577
os_in_token_free(void * drv_priv)578 static __inline void os_in_token_free(void *drv_priv)
579 {
580 // Free in token (pUrb) list
581 }
582
583
os_send_usb_in_token(void * drv_priv,void * rxobj,u8 * inbuf,u32 inbuf_len,u8 pipe_idx,u8 minLen)584 static __inline u8 os_send_usb_in_token(void *drv_priv, void *rxobj, u8 *inbuf, u32 inbuf_len, u8 pipe_idx, u8 minLen)
585 {
586 // send rtw_rx_buf to os
587 return 0;
588 }
589
os_enable_usb_in_pipes(void * drv_priv)590 static __inline void os_enable_usb_in_pipes(void *drv_priv)
591 {
592 }
593
os_disable_usb_in_pipes(void * drv_priv)594 static __inline void os_disable_usb_in_pipes(void *drv_priv)
595 {
596 }
597
598 #endif /*CONFIG_USB_HCI*/
599
600 #ifdef CONFIG_SDIO_HCI
_os_sdio_cmd52_r8(void * d,u32 offset)601 static inline u8 _os_sdio_cmd52_r8(void *d, u32 offset)
602 {
603 return 0;
604 }
605
_os_sdio_cmd53_r8(void * d,u32 offset)606 static inline u8 _os_sdio_cmd53_r8(void *d, u32 offset)
607 {
608 return 0;
609 }
610
_os_sdio_cmd53_r16(void * d,u32 offset)611 static inline u16 _os_sdio_cmd53_r16(void *d, u32 offset)
612 {
613 return 0;
614 }
615
_os_sdio_cmd53_r32(void * d,u32 offset)616 static inline u32 _os_sdio_cmd53_r32(void *d, u32 offset)
617 {
618 return 0;
619 }
620
_os_sdio_cmd53_rn(void * d,u32 offset,u32 size,u8 * data)621 static inline u8 _os_sdio_cmd53_rn(void *d, u32 offset, u32 size, u8 *data)
622 {
623 return 0;
624 }
625
_os_sdio_cmd53_r(void * d,u32 offset,u32 size,u8 * data)626 static inline u8 _os_sdio_cmd53_r(void *d, u32 offset, u32 size, u8 *data)
627 {
628 return 0;
629 }
630
_os_sdio_cmd52_w8(void * d,u32 offset,u8 val)631 static inline void _os_sdio_cmd52_w8(void *d, u32 offset, u8 val)
632 {
633 }
634
_os_sdio_cmd53_w8(void * d,u32 offset,u8 val)635 static inline void _os_sdio_cmd53_w8(void *d, u32 offset, u8 val)
636 {
637 }
638
_os_sdio_cmd53_w16(void * d,u32 offset,u16 val)639 static inline void _os_sdio_cmd53_w16(void *d, u32 offset, u16 val)
640 {
641 }
642
_os_sdio_cmd53_w32(void * d,u32 offset,u32 val)643 static inline void _os_sdio_cmd53_w32(void *d, u32 offset, u32 val)
644 {
645 }
646
_os_sdio_cmd53_wn(void * d,u32 offset,u32 size,u8 * data)647 static inline void _os_sdio_cmd53_wn(void *d, u32 offset, u32 size, u8 *data)
648 {
649 }
650
_os_sdio_cmd53_w(void * d,u32 offset,u32 size,u8 * data)651 static inline void _os_sdio_cmd53_w(void *d, u32 offset, u32 size, u8 *data)
652 {
653 }
654
_os_sdio_f0_read(void * d,u32 addr,void * buf,size_t len)655 static inline u8 _os_sdio_f0_read(void *d, u32 addr, void *buf, size_t len)
656 {
657 return 0;
658 }
659
_os_sdio_read_cia_r8(void * d,u32 addr)660 static inline u8 _os_sdio_read_cia_r8(void *d, u32 addr)
661 {
662 return 0;
663 }
664 #endif /*CONFIG_SDIO_HCI*/
665
666
667 /*
668 * Continuous bits starting from least significant bit
669 * Example:
670 * BIT_LEN_MASK_32(0) => 0x00000000
671 * BIT_LEN_MASK_32(1) => 0x00000001
672 * BIT_LEN_MASK_32(2) => 0x00000003
673 * BIT_LEN_MASK_32(32) => 0xFFFFFFFF
674 */
675 #define BIT_LEN_MASK_32(__BitLen) ((u32)(0xFFFFFFFF >> (32 - (__BitLen))))
676 #define BIT_LEN_MASK_16(__BitLen) ((u16)(0xFFFF >> (16 - (__BitLen))))
677 #define BIT_LEN_MASK_8(__BitLen) ((u8)(0xFF >> (8 - (__BitLen))))
678
679 /*
680 * Continuous bits starting from least significant bit
681 * Example:
682 * BIT_OFFSET_LEN_MASK_32(0, 2) => 0x00000003
683 * BIT_OFFSET_LEN_MASK_32(16, 2) => 0x00030000
684 */
685 #define BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen) ((u32)(BIT_LEN_MASK_32(__BitLen) << (__BitOffset)))
686 #define BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen) ((u16)(BIT_LEN_MASK_16(__BitLen) << (__BitOffset)))
687 #define BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen) ((u8)(BIT_LEN_MASK_8(__BitLen) << (__BitOffset)))
688
689 /*
690 * Convert LE data to host byte order
691 */
692 #define EF1Byte (u8)
693 #define EF2Byte le16_to_cpu
694 #define EF4Byte le32_to_cpu
695
696 /*
697 * Read LE data from memory to host byte order
698 */
699 #define ReadLE4Byte(_ptr) le32_to_cpu(*((u32 *)(_ptr)))
700 #define ReadLE2Byte(_ptr) le16_to_cpu(*((u16 *)(_ptr)))
701 #define ReadLE1Byte(_ptr) (*((u8 *)(_ptr)))
702
703 /*
704 * Read BE data from memory to host byte order
705 */
706 #define ReadBEE4Byte(_ptr) be32_to_cpu(*((u32 *)(_ptr)))
707 #define ReadBE2Byte(_ptr) be16_to_cpu(*((u16 *)(_ptr)))
708 #define ReadBE1Byte(_ptr) (*((u8 *)(_ptr)))
709
710 /*
711 * Write host byte order data to memory in LE order
712 */
713 #define WriteLE4Byte(_ptr, _val) ((*((u32 *)(_ptr))) = cpu_to_le32(_val))
714 #define WriteLE2Byte(_ptr, _val) ((*((u16 *)(_ptr))) = cpu_to_le16(_val))
715 #define WriteLE1Byte(_ptr, _val) ((*((u8 *)(_ptr))) = ((u8)(_val)))
716
717 /*
718 * Write host byte order data to memory in BE order
719 */
720 #define WriteBE4Byte(_ptr, _val) ((*((u32 *)(_ptr))) = cpu_to_be32(_val))
721 #define WriteBE2Byte(_ptr, _val) ((*((u16 *)(_ptr))) = cpu_to_be16(_val))
722 #define WriteBE1Byte(_ptr, _val) ((*((u8 *)(_ptr))) = ((u8)(_val)))
723
724 /*
725 * Return 4-byte value in host byte ordering from 4-byte pointer in litten-endian system.
726 */
727 #define LE_P4BYTE_TO_HOST_4BYTE(__pStart) (le32_to_cpu(*((u32 *)(__pStart))))
728 #define LE_P2BYTE_TO_HOST_2BYTE(__pStart) (le16_to_cpu(*((u16 *)(__pStart))))
729 #define LE_P1BYTE_TO_HOST_1BYTE(__pStart) ((*((u8 *)(__pStart))))
730
731 /*
732 * Return 4-byte value in host byte ordering from 4-byte pointer in big-endian system.
733 */
734 #define BE_P4BYTE_TO_HOST_4BYTE(__pStart) (be32_to_cpu(*((u32 *)(__pStart))))
735 #define BE_P2BYTE_TO_HOST_2BYTE(__pStart) (be16_to_cpu(*((u16 *)(__pStart))))
736 #define BE_P1BYTE_TO_HOST_1BYTE(__pStart) ((*((u8 *)(__pStart))))
737
738 /*
739 * Translate subfield (continuous bits in little-endian) of 4-byte value in LE byte to
740 * 4-byte value in host byte ordering.
741 */
742 #define LE_BITS_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
743 ((LE_P4BYTE_TO_HOST_4BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_32(__BitLen))
744
745 #define LE_BITS_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
746 ((LE_P2BYTE_TO_HOST_2BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_16(__BitLen))
747
748 #define LE_BITS_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
749 ((LE_P1BYTE_TO_HOST_1BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_8(__BitLen))
750
751 /*
752 * Translate subfield (continuous bits in big-endian) of 4-byte value in BE byte to
753 * 4-byte value in host byte ordering.
754 */
755 #define BE_BITS_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
756 ((BE_P4BYTE_TO_HOST_4BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_32(__BitLen))
757
758 #define BE_BITS_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
759 ((BE_P2BYTE_TO_HOST_2BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_16(__BitLen))
760
761 #define BE_BITS_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
762 ((BE_P1BYTE_TO_HOST_1BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_8(__BitLen))
763
764 /*
765 * Mask subfield (continuous bits in little-endian) of 4-byte value in LE byte oredering
766 * and return the result in 4-byte value in host byte ordering.
767 */
768 #define LE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
769 (LE_P4BYTE_TO_HOST_4BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen)))
770
771 #define LE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
772 (LE_P2BYTE_TO_HOST_2BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen)))
773
774 #define LE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
775 (LE_P1BYTE_TO_HOST_1BYTE(__pStart) & ((u8)(~BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen))))
776
777 /*
778 * Mask subfield (continuous bits in big-endian) of 4-byte value in BE byte oredering
779 * and return the result in 4-byte value in host byte ordering.
780 */
781 #define BE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
782 (BE_P4BYTE_TO_HOST_4BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen)))
783
784 #define BE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
785 (BE_P2BYTE_TO_HOST_2BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen)))
786
787 #define BE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
788 (BE_P1BYTE_TO_HOST_1BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen)))
789
790 /*
791 * Set subfield of little-endian 4-byte value to specified value.
792 */
793 #define SET_BITS_TO_LE_4BYTE(__pStart, __BitOffset, __BitLen, __Value) \
794 do { \
795 u8 __offset = __BitOffset, __len = __BitLen; \
796 if (__offset == 0 && __len == 32) \
797 WriteLE4Byte(__pStart, __Value); \
798 else { \
799 WriteLE4Byte(__pStart, \
800 LE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
801 | \
802 ((((u32)__Value) & BIT_LEN_MASK_32(__BitLen)) << (__BitOffset)) \
803 ); \
804 } \
805 } while (0)
806
807 #define SET_BITS_TO_LE_2BYTE(__pStart, __BitOffset, __BitLen, __Value) \
808 do { \
809 WriteLE2Byte(__pStart, \
810 LE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
811 | \
812 ((((u16)__Value) & BIT_LEN_MASK_16(__BitLen)) << (__BitOffset)) \
813 ); \
814 } while (0)
815
816 #define SET_BITS_TO_LE_1BYTE(__pStart, __BitOffset, __BitLen, __Value) \
817 do { \
818 u8 __offset = __BitOffset; u8 __len = __BitLen; \
819 if (__offset == 0 && __len == 8) \
820 WriteLE1Byte(__pStart, __Value); \
821 else { \
822 WriteLE1Byte(__pStart, \
823 LE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __len) \
824 | \
825 ((((u8)__Value) & BIT_LEN_MASK_8(__len)) << (__BitOffset)) \
826 ); \
827 } \
828 } while (0)
829
830 /*
831 * Set subfield of big-endian 4-byte value to specified value.
832 */
833 #define SET_BITS_TO_BE_4BYTE(__pStart, __BitOffset, __BitLen, __Value) \
834 do { \
835 if (__BitOffset == 0 && __BitLen == 32) \
836 WriteBE4Byte(__pStart, __Value); \
837 else { \
838 WriteBE4Byte(__pStart, \
839 BE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
840 | \
841 ((((u32)__Value) & BIT_LEN_MASK_32(__BitLen)) << (__BitOffset)) \
842 ); \
843 } \
844 } while (0)
845
846 #define SET_BITS_TO_BE_2BYTE(__pStart, __BitOffset, __BitLen, __Value) \
847 do { \
848 if (__BitOffset == 0 && __BitLen == 16) \
849 WriteBE2Byte(__pStart, __Value); \
850 else { \
851 WriteBE2Byte(__pStart, \
852 BE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
853 | \
854 ((((u16)__Value) & BIT_LEN_MASK_16(__BitLen)) << (__BitOffset)) \
855 ); \
856 } \
857 } while (0)
858
859 #define SET_BITS_TO_BE_1BYTE(__pStart, __BitOffset, __BitLen, __Value) \
860 do { \
861 if (__BitOffset == 0 && __BitLen == 8) \
862 WriteBE1Byte(__pStart, __Value); \
863 else { \
864 WriteBE1Byte(__pStart, \
865 BE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
866 | \
867 ((((u8)__Value) & BIT_LEN_MASK_8(__BitLen)) << (__BitOffset)) \
868 ); \
869 } \
870 } while (0)
871
872 #endif /*_PLTFM_OPS_NONE_H_*/
873