osmo-sdr/firmware/usb-dfu-project/hardware.c @ master
1 | 5dcfd6a1 | Christian Daniel | /**************************************************************
|
---|---|---|---|
2 | *
|
||
3 | * Lattice Semiconductor Corp. Copyright 2008
|
||
4 | *
|
||
5 | *
|
||
6 | ***************************************************************/
|
||
7 | |||
8 | |||
9 | /**************************************************************
|
||
10 | *
|
||
11 | * Revision History of hardware.c
|
||
12 | *
|
||
13 | *
|
||
14 | * 09/11/07 NN type cast all the mismatch variables
|
||
15 | ***************************************************************/
|
||
16 | |||
17 | #include <stdio.h>
|
||
18 | #include <unistd.h>
|
||
19 | #include "opcode.h"
|
||
20 | #include "hardware.h"
|
||
21 | |||
22 | /*************************************************************
|
||
23 | * *
|
||
24 | * EXTERNAL FUNCTION *
|
||
25 | * *
|
||
26 | *************************************************************/
|
||
27 | |||
28 | extern void ispVMStateMachine( char a_cNextState ); |
||
29 | |||
30 | /*************************************************************
|
||
31 | * *
|
||
32 | * READPORT *
|
||
33 | * *
|
||
34 | * INPUT: *
|
||
35 | * None. *
|
||
36 | * *
|
||
37 | * RETURN: *
|
||
38 | * Returns the bit read back from the device. *
|
||
39 | * *
|
||
40 | * DESCRIPTION: *
|
||
41 | * This function is used to read the TDO pin from the *
|
||
42 | * input port. *
|
||
43 | * *
|
||
44 | * NOTE: This function should be modified in an embedded *
|
||
45 | * system! *
|
||
46 | * *
|
||
47 | *************************************************************/
|
||
48 | |||
49 | int readPort() |
||
50 | {
|
||
51 | uint32_t value; |
||
52 | |||
53 | value = *((volatile uint32_t*)(0x400e0e00 + 0x3c)); |
||
54 | |||
55 | if(value & (1 << 6)) |
||
56 | return 1; |
||
57 | else return 0; |
||
58 | }
|
||
59 | |||
60 | /*************************************************************
|
||
61 | * *
|
||
62 | * WRITEPORT *
|
||
63 | * *
|
||
64 | * INPUT: *
|
||
65 | * a_ucPins: a byte to indicate which pin will be *
|
||
66 | * depending on the value. *
|
||
67 | * *
|
||
68 | * a_ucValue: the value to determine of the pin above *
|
||
69 | * will be written out or not. *
|
||
70 | * *
|
||
71 | * RETURN: *
|
||
72 | * None. *
|
||
73 | * *
|
||
74 | * DESCRIPTION: *
|
||
75 | * To apply the specified value to the pins indicated. *
|
||
76 | * This routine will likely be modified for specific *
|
||
77 | * systems. As an example, this code is for the PC, as *
|
||
78 | * described below. *
|
||
79 | * *
|
||
80 | * This routine uses the IBM-PC standard Parallel port, *
|
||
81 | * along with the schematic shown in Lattice *
|
||
82 | * documentation, to apply the signals to the programming *
|
||
83 | * loop. *
|
||
84 | * *
|
||
85 | * NOTE: This function should be modified in an embedded *
|
||
86 | * system! *
|
||
87 | * *
|
||
88 | *************************************************************/
|
||
89 | |||
90 | void writePort( unsigned int a_ucPins, unsigned int a_ucValue ) |
||
91 | {
|
||
92 | uint32_t value = 0; |
||
93 | |||
94 | if(a_ucPins & pinTDI) |
||
95 | value |= (1 << 8); |
||
96 | if(a_ucPins & pinTCK) |
||
97 | value |= (1 << 7); |
||
98 | if(a_ucPins & pinTMS) |
||
99 | value |= (1 << 5); |
||
100 | |||
101 | if(a_ucValue) |
||
102 | *((volatile uint32_t*)(0x400e0e00 + 0x30)) = value; |
||
103 | else *((volatile uint32_t*)(0x400e0e00 + 0x34)) = value; |
||
104 | }
|
||
105 | |||
106 | /*************************************************************
|
||
107 | * *
|
||
108 | * ISPVMDELAY *
|
||
109 | * *
|
||
110 | * INPUT: *
|
||
111 | * a_uiDelay: delay in milliseconds *
|
||
112 | * *
|
||
113 | * RETURN: *
|
||
114 | * None. *
|
||
115 | * *
|
||
116 | * DESCRIPTION: *
|
||
117 | * The user must implement a delay to observe a_uiDelay, *
|
||
118 | * where a_uiDelay is the number of milliseconds that must *
|
||
119 | * pass before data is read from in_port. Since platforms and*
|
||
120 | * processor speeds vary greatly, this task is left to the *
|
||
121 | * user. This subroutine is called upon to provide a delay *
|
||
122 | * from 1 millisecond to a few hundreds milliseconds each time*
|
||
123 | * That is the reason behind using unsigned long integer in *
|
||
124 | * this subroutine. It is OK to provide longer delay than *
|
||
125 | * required. It is not acceptable if the delay is shorter than*
|
||
126 | * required. *
|
||
127 | * *
|
||
128 | * Note: user must re - implement to target specific hardware.*
|
||
129 | * *
|
||
130 | * Example: Use the for loop to create the microsecond delay. *
|
||
131 | * Loop 1K times to produce the milliseconds delay. *
|
||
132 | * *
|
||
133 | * Let the CPU clock (system clock) be F Mhz. *
|
||
134 | * *
|
||
135 | * Let the for loop represented by the 2 lines of *
|
||
136 | * machine code: *
|
||
137 | * LOOP: DEC RA; *
|
||
138 | * JNZ LOOP; *
|
||
139 | * Let the for loop number for one microsecond be L. *
|
||
140 | * Lets assume 4 system clocks for each line of *
|
||
141 | * machine code. *
|
||
142 | * Then 1 us = 1/F (microseconds per clock) *
|
||
143 | * x (2 lines) x (4 clocks per line) x L*
|
||
144 | * = 8L/F *
|
||
145 | * Or L = F/8; *
|
||
146 | * *
|
||
147 | * Convert the unit in microseconds to *
|
||
148 | * milliseconds. *
|
||
149 | * L = F/8 x 1000; *
|
||
150 | * Lets assume the CPU clock is set to 48MHZ. The C *
|
||
151 | * code then is: *
|
||
152 | * *
|
||
153 | * unsigned int F = 48; //MHZ. *
|
||
154 | * unsigned int L = F/8; //microseconds. *
|
||
155 | * unsigned int index, m; *
|
||
156 | * *
|
||
157 | * *
|
||
158 | * if (L < 1) L = 1; //minimum is i microsecond. *
|
||
159 | * for (index=0; index < a_uiDelay * L; index++) *
|
||
160 | * { *
|
||
161 | * //loop 1K times to produce milliseconds delay *
|
||
162 | * for (m=0; m<1000; m++); //milliseconds *
|
||
163 | * } *
|
||
164 | * return 0; *
|
||
165 | * *
|
||
166 | * *
|
||
167 | *************************************************************/
|
||
168 | |||
169 | /* the unit of a_uiDelay is milliseconds */
|
||
170 | void ispVMDelay( unsigned int a_uiDelay ) |
||
171 | {
|
||
172 | // yes, this is more or less calibrated - cd
|
||
173 | volatile int i, j; |
||
174 | for(i = 0; i < a_uiDelay; i++) { |
||
175 | for(j = 0; j < 5000; j++) |
||
176 | asm("nop"); |
||
177 | }
|
||
178 | }
|
||
179 | |||
180 | /*************************************************************
|
||
181 | * *
|
||
182 | * ENABLEHARDWARE *
|
||
183 | * *
|
||
184 | * INPUT: *
|
||
185 | * None. *
|
||
186 | * *
|
||
187 | * RETURN: *
|
||
188 | * None. *
|
||
189 | * *
|
||
190 | * DESCRIPTION: *
|
||
191 | * This function is called to enable the hardware. *
|
||
192 | * *
|
||
193 | * NOTE: This function should be modified in an embedded *
|
||
194 | * system! *
|
||
195 | * *
|
||
196 | *************************************************************/
|
||
197 | |||
198 | void EnableHardware() |
||
199 | {
|
||
200 | ispVMStateMachine(RESET); |
||
201 | }
|
||
202 | |||
203 | /*************************************************************
|
||
204 | * *
|
||
205 | * DISABLEHARDWARE *
|
||
206 | * *
|
||
207 | * INPUT: *
|
||
208 | * None. *
|
||
209 | * *
|
||
210 | * RETURN: *
|
||
211 | * None. *
|
||
212 | * *
|
||
213 | * DESCRIPTION: *
|
||
214 | * This function is called to disable the hardware. *
|
||
215 | * *
|
||
216 | * NOTE: This function should be modified in an embedded *
|
||
217 | * system! *
|
||
218 | * *
|
||
219 | *************************************************************/
|
||
220 | |||
221 | void DisableHardware() |
||
222 | {
|
||
223 | ispVMStateMachine(RESET); |
||
224 | }
|
||
225 |