1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
#define _USB_OSAI_EXT_
#include <linux/mu3d/hal/mu3d_hal_osal.h>
#undef _USB_OSAI_EXT_
extern DEV_INT32 rand(void);
extern void HalFlushInvalidateDCache(void);
void os_ms_delay(unsigned int ui4_delay){
mdelay(ui4_delay);
}
void os_us_delay(unsigned int ui4_delay){
udelay(ui4_delay);
}
void os_ms_sleep(unsigned int ui4_sleep){
msleep(ui4_sleep);
}
#ifdef NEVER
void os_spin_lock(spinlock_t *lock){
//spin_lock(lock);
}
void os_spin_unlock(spinlock_t *lock){
//spin_unlock(lock);
}
#endif /* NEVER */
void os_memcpy(DEV_INT8 *pv_to, DEV_INT8 *pv_from, size_t z_l) {
/*FIXME: just use memcpy(), why use this????*/
DEV_INT32 i;
if ((pv_to != NULL) || (z_l == 0)) {
for(i=0;i<z_l;i++){
*(pv_to+i) = *(pv_from+i);
}
} else {
BUG_ON(1);
}
}
#ifdef NEVER
void *os_virt_to_phys(void *vaddr){
return virt_to_phys(vaddr);
}
#endif /* NEVER */
void *os_phys_to_virt(void *paddr){
//return phys_to_virt((phys_addr_t)paddr);
return phys_to_virt((phys_addr_t)(long)paddr);
}
#ifdef NEVER
void *os_ioremap(void *paddr,DEV_UINT32 t_size){
//return ioremap(paddr,t_size);
return ioremap_nocache(paddr,t_size);
}
void os_iounmap(void *vaddr){
iounmap(vaddr);
vaddr = NULL;
}
#endif /* NEVER */
void *os_memset(void *pv_to, DEV_UINT8 ui1_c, size_t z_l){
if ((pv_to != NULL) || (z_l == 0)) {
return memset(pv_to, ui1_c, z_l);
} else {
BUG_ON(1);
}
return pv_to;
}
void *os_mem_alloc(size_t z_size){
void *pv_mem = NULL;
pv_mem = kmalloc(z_size, GFP_NOIO);
if(pv_mem==NULL) {
printk("kmalloc fail!!\n");
BUG_ON(1);
}
return(pv_mem);
}
void os_mem_free(void *pv_mem){
kfree(pv_mem);
pv_mem = NULL;
}
void os_disableIrq(DEV_UINT32 irq){
disable_irq(irq);
os_ms_delay(20);
}
void os_enableIrq(DEV_UINT32 irq){
enable_irq(irq);
}
void os_clearIrq(DEV_UINT32 irq){
os_writel(U3D_LV1IECR, os_readl(U3D_LV1ISR));
}
void os_get_random_bytes(void *buf,DEV_INT32 nbytes){
get_random_bytes(buf, nbytes);
}
void os_disableDcache(void){
//HalDisableDCache();
}
void os_flushinvalidateDcache(void){
//HalFlushInvalidateDCache();
}
/*----------------------------------------------------------------------------
* Function: os_reg_isr()
*
* Description:
* this API registers an ISR with its vector id. it performs
* 1. parse argument.
* 2. guard isr.
* 3. call OS driver reg isr API.
*
* Inputs:
* ui2_vec_id: an vector id to register an ISR.
* pf_isr: pointer to a ISR to set.
* ppf_old_isr: pointer to hold the current ISR setting.
*
* Outputs:
* None
*---------------------------------------------------------------------------*/
int os_reg_isr(DEV_UINT32 irq,
irq_handler_t handler,
void *isrbuffer){
DEV_INT32 i4_ret;
i4_ret = request_irq(irq,
handler, /* our handler */
IRQF_TRIGGER_LOW,
"usb device handler", isrbuffer);
return(i4_ret);
}
void os_free_isr(DEV_UINT32 irq,void *isrbuffer){
free_irq(irq, isrbuffer);
}
|
