1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdint.h>
4 #include <hal_osal.h>
5
6 #include "usb_os_platform.h"
7 #include "sunxi_hal_common.h"
8
9 hal_spinlock_t lock;
10
11
usb_dma_malloc(uint32_t size,dma_addr_t * p_addr)12 void *usb_dma_malloc(uint32_t size, dma_addr_t *p_addr)
13 {
14 void *v_addr = NULL;
15
16 /* should be 32 byte-align for QH and QTD */
17 v_addr = dma_alloc_coherent(size);
18 if (v_addr) {
19 *p_addr = __va_to_pa((unsigned long)v_addr);
20 memset(v_addr, 0, size);
21 return v_addr;
22 }
23
24 hal_log_err("hal_malloc failed\n");
25 return NULL;
26 }
27
usb_dma_free(void * v_addr,dma_addr_t p_addr)28 void usb_dma_free(void *v_addr, dma_addr_t p_addr)
29 {
30 if (v_addr)
31 dma_free_coherent(v_addr);
32 }
33
usb_set_bit(int bit_nr,volatile uint32_t * addr)34 void usb_set_bit(int bit_nr, volatile uint32_t *addr)
35 {
36 int32_t mask;
37 uint32_t cpu_sr;
38 volatile uint32_t *p = addr;
39 p += ((bit_nr & 0xffffffe0) >> 5);
40 mask = 1 << (bit_nr & 0x1f);
41 cpu_sr = hal_spin_lock_irqsave(&lock);
42 (*p) |= mask;
43 hal_spin_unlock_irqrestore(&lock, cpu_sr);
44 }
usb_clear_bit(int bit_nr,volatile uint32_t * addr)45 void usb_clear_bit(int bit_nr, volatile uint32_t *addr)
46 {
47 int32_t mask;
48 uint32_t cpu_sr;
49 volatile uint32_t *p = addr;
50 p += ((bit_nr & 0xffffffe0) >> 5);
51 mask = 1 << (bit_nr & 0x1f);
52 cpu_sr = hal_spin_lock_irqsave(&lock);
53 (*p) &= (~mask);
54 hal_spin_unlock_irqrestore(&lock, cpu_sr);
55 }
usb_test_bit(int bit_nr,volatile uint32_t * addr)56 uint32_t usb_test_bit(int bit_nr, volatile uint32_t *addr)
57 {
58 uint32_t ret;
59 uint32_t cpu_sr;
60 volatile uint32_t *p = addr;
61 p += ((bit_nr & 0xffffffe0) >> 5);
62 cpu_sr = hal_spin_lock_irqsave(&lock);
63 ret = ((*p) >> (bit_nr & 31)) & 1;
64 hal_spin_unlock_irqrestore(&lock, cpu_sr);
65 return ret;
66 }
usb_test_and_clear_bit(int bit_nr,volatile uint32_t * addr)67 uint32_t usb_test_and_clear_bit(int bit_nr, volatile uint32_t *addr)
68 {
69 uint32_t ret, mask;
70 uint32_t cpu_sr;
71 mask = 1 << (bit_nr & 0x1f);
72 cpu_sr = hal_spin_lock_irqsave(&lock);
73 ret = ((mask & *addr) != 0);
74 *addr &= ~mask;
75 hal_spin_unlock_irqrestore(&lock, cpu_sr);
76 return ret;
77 }
usb_clear_bit32(int bit_nr,volatile uint32_t * addr)78 void usb_clear_bit32(int bit_nr, volatile uint32_t *addr)
79 {
80 uint32_t cpu_sr;
81 int32_t mask;
82 mask = 1 << (bit_nr & 0x1f);
83 cpu_sr = hal_spin_lock_irqsave(&lock);
84 *addr &= ~mask;
85 hal_spin_unlock_irqrestore(&lock, cpu_sr);
86 }
usb_dec32(uint32_t * addr)87 void usb_dec32(uint32_t *addr)
88 {
89 uint32_t cpu_sr;
90 cpu_sr = hal_spin_lock_irqsave(&lock);
91 *addr = *addr - 1;
92 hal_spin_unlock_irqrestore(&lock, cpu_sr);
93 }
usb_inc32(uint32_t * addr)94 void usb_inc32(uint32_t *addr)
95 {
96 uint32_t cpu_sr;
97 cpu_sr = hal_spin_lock_irqsave(&lock);
98 *addr = *addr + 1;
99 hal_spin_unlock_irqrestore(&lock, cpu_sr);
100 }
le16_to_cpu(uint16_t x)101 uint16_t le16_to_cpu(uint16_t x)
102 {
103 return x;
104 }
le32_to_cpu(uint32_t x)105 uint32_t le32_to_cpu(uint32_t x)
106 {
107 return x;
108 }
le32_to_cpup(const uint32_t * x)109 uint32_t le32_to_cpup(const uint32_t *x)
110 {
111 return *x;
112 }
Usb_uint2str_dec(unsigned int input,char * str)113 void Usb_uint2str_dec(unsigned int input, char *str)
114 {
115 char stack[11] = {0};
116 int i ;
117 int j ;
118
119 if (input == 0)
120 {
121 str[0] = '0';
122 str[1] = '\0'; // 'str' must end with '\0'
123 return ;
124 }
125
126 for (i = 0; input > 0; ++i)
127 {
128 stack[i] = input % 10 + '0'; // characters in reverse order are put in 'stack' .
129 input /= 10;
130 } // at the end of 'for' loop, 'i' is the number of characters.
131
132 for (--i, j = 0; i >= 0; --i, ++j)
133 {
134 str[j] = stack[i];
135 }
136
137 str[j] = '\0'; // 'str' must end with '\0'
138 }
139
140