diff options
Diffstat (limited to 'firmware/target/arm/tms320dm320')
-rw-r--r-- | firmware/target/arm/tms320dm320/mrobe-500/button-mr500.c | 40 | ||||
-rw-r--r-- | firmware/target/arm/tms320dm320/mrobe-500/lcd-remote-mr500.c | 204 | ||||
-rw-r--r-- | firmware/target/arm/tms320dm320/uart-dm320.c | 121 | ||||
-rw-r--r-- | firmware/target/arm/tms320dm320/uart-target.h | 6 |
4 files changed, 207 insertions, 164 deletions
diff --git a/firmware/target/arm/tms320dm320/mrobe-500/button-mr500.c b/firmware/target/arm/tms320dm320/mrobe-500/button-mr500.c index bc163b1070..00096ce2ad 100644 --- a/firmware/target/arm/tms320dm320/mrobe-500/button-mr500.c +++ b/firmware/target/arm/tms320dm320/mrobe-500/button-mr500.c | |||
@@ -186,27 +186,26 @@ int button_read_device(int *data) | |||
186 | } | 186 | } |
187 | 187 | ||
188 | retval=uart1_gets_queue(r_buffer, 5); | 188 | retval=uart1_gets_queue(r_buffer, 5); |
189 | do | 189 | |
190 | for(calbuf=0;calbuf<4;calbuf++) | ||
190 | { | 191 | { |
191 | for(calbuf=0;calbuf<4;calbuf++) | 192 | if((r_buffer[calbuf]&0xF0)==0xF0 && (r_buffer[calbuf+1]&0xF0)!=0xF0) |
192 | { | 193 | break; |
193 | if((r_buffer[calbuf]&0xF0)==0xF0 && (r_buffer[calbuf+1]&0xF0)!=0xF0) | 194 | } |
194 | break; | 195 | calbuf++; |
195 | } | 196 | if(calbuf==5) |
196 | calbuf++; | 197 | calbuf=0; |
197 | if(calbuf==5) | 198 | if(retval>=0) |
198 | calbuf=0; | 199 | { |
199 | if(retval>=0) | 200 | uart1_clear_queue(); |
200 | { | 201 | r_button |= r_buffer[calbuf]; |
201 | r_button |= r_buffer[calbuf]; | 202 | oldbutton=r_button; |
202 | oldbutton=r_button; | 203 | } |
203 | } | 204 | else |
204 | else | 205 | { |
205 | { | 206 | r_button=oldbutton; |
206 | r_button=oldbutton; | 207 | } |
207 | } | 208 | |
208 | } while((retval=uart1_gets_queue(r_buffer, 5))>=5); | ||
209 | |||
210 | return r_button; | 209 | return r_button; |
211 | } | 210 | } |
212 | 211 | ||
@@ -226,6 +225,5 @@ void GIO14(void) | |||
226 | read_battery_inputs(); | 225 | read_battery_inputs(); |
227 | break; | 226 | break; |
228 | } | 227 | } |
229 | //touch_available = true; | ||
230 | IO_INTC_IRQ2 = (1<<3); /* IRQ_GIO14 == 35 */ | 228 | IO_INTC_IRQ2 = (1<<3); /* IRQ_GIO14 == 35 */ |
231 | } | 229 | } |
diff --git a/firmware/target/arm/tms320dm320/mrobe-500/lcd-remote-mr500.c b/firmware/target/arm/tms320dm320/mrobe-500/lcd-remote-mr500.c index 5cdc00ce6a..0a41b2241f 100644 --- a/firmware/target/arm/tms320dm320/mrobe-500/lcd-remote-mr500.c +++ b/firmware/target/arm/tms320dm320/mrobe-500/lcd-remote-mr500.c | |||
@@ -33,17 +33,22 @@ static enum remote_control_states | |||
33 | REMOTE_CONTROL_NOP, | 33 | REMOTE_CONTROL_NOP, |
34 | REMOTE_CONTROL_POWER, | 34 | REMOTE_CONTROL_POWER, |
35 | REMOTE_CONTROL_MASK, | 35 | REMOTE_CONTROL_MASK, |
36 | REMOTE_CONTROL_DRAW1, | 36 | REMOTE_CONTROL_DRAW, |
37 | REMOTE_CONTROL_DRAW_PAUSE1, | ||
38 | REMOTE_CONTROL_DRAW2, | ||
39 | REMOTE_CONTROL_DRAW_PAUSE2, | ||
40 | REMOTE_CONTROL_SLEEP | 37 | REMOTE_CONTROL_SLEEP |
41 | } remote_state_control = REMOTE_CONTROL_NOP; | 38 | } remote_state_control = REMOTE_CONTROL_NOP, remote_state_control_next; |
39 | |||
40 | static enum remote_draw_states | ||
41 | { | ||
42 | DRAW_TOP, | ||
43 | DRAW_BOTTOM, | ||
44 | DRAW_PAUSE, | ||
45 | } remote_state_draw = DRAW_TOP, remote_state_draw_next; | ||
42 | 46 | ||
43 | bool remote_initialized=true; | 47 | bool remote_initialized=true; |
44 | 48 | ||
45 | unsigned char remote_contrast=DEFAULT_REMOTE_CONTRAST_SETTING; | 49 | unsigned char remote_contrast=DEFAULT_REMOTE_CONTRAST_SETTING; |
46 | unsigned char remote_power=0x00; | 50 | unsigned char remote_power=0x00; |
51 | unsigned char remote_mask=0x00; | ||
47 | 52 | ||
48 | /*** hardware configuration ***/ | 53 | /*** hardware configuration ***/ |
49 | 54 | ||
@@ -54,7 +59,7 @@ int lcd_remote_default_contrast(void) | |||
54 | 59 | ||
55 | void lcd_remote_sleep(void) | 60 | void lcd_remote_sleep(void) |
56 | { | 61 | { |
57 | remote_state_control=REMOTE_CONTROL_SLEEP; | 62 | remote_state_control_next=REMOTE_CONTROL_SLEEP; |
58 | } | 63 | } |
59 | 64 | ||
60 | void lcd_remote_powersave(bool on) | 65 | void lcd_remote_powersave(bool on) |
@@ -62,19 +67,19 @@ void lcd_remote_powersave(bool on) | |||
62 | if(on) | 67 | if(on) |
63 | { | 68 | { |
64 | remote_power|=0xC0; | 69 | remote_power|=0xC0; |
65 | remote_state_control=REMOTE_CONTROL_POWER; | 70 | remote_state_control_next=REMOTE_CONTROL_POWER; |
66 | } | 71 | } |
67 | else | 72 | else |
68 | { | 73 | { |
69 | remote_power&=~(0xC0); | 74 | remote_power&=~(0xC0); |
70 | remote_state_control=REMOTE_CONTROL_POWER; | 75 | remote_state_control_next=REMOTE_CONTROL_POWER; |
71 | } | 76 | } |
72 | } | 77 | } |
73 | 78 | ||
74 | void lcd_remote_set_contrast(int val) | 79 | void lcd_remote_set_contrast(int val) |
75 | { | 80 | { |
76 | remote_contrast=(char)val; | 81 | remote_contrast=(char)val; |
77 | remote_state_control=REMOTE_CONTROL_POWER; | 82 | remote_state_control_next=REMOTE_CONTROL_POWER; |
78 | } | 83 | } |
79 | 84 | ||
80 | void lcd_remote_set_invert_display(bool yesno) | 85 | void lcd_remote_set_invert_display(bool yesno) |
@@ -82,12 +87,6 @@ void lcd_remote_set_invert_display(bool yesno) | |||
82 | (void)yesno; | 87 | (void)yesno; |
83 | } | 88 | } |
84 | 89 | ||
85 | /* turn the display upside down (call lcd_remote_update() afterwards) */ | ||
86 | void lcd_remote_set_flip(bool yesno) | ||
87 | { | ||
88 | (void)yesno; | ||
89 | } | ||
90 | |||
91 | bool remote_detect(void) | 90 | bool remote_detect(void) |
92 | { | 91 | { |
93 | return true; | 92 | return true; |
@@ -96,32 +95,41 @@ bool remote_detect(void) | |||
96 | void lcd_remote_on(void) | 95 | void lcd_remote_on(void) |
97 | { | 96 | { |
98 | remote_power|=0x80; | 97 | remote_power|=0x80; |
99 | remote_state_control=REMOTE_CONTROL_POWER; | 98 | remote_state_control_next=REMOTE_CONTROL_POWER; |
100 | } | 99 | } |
101 | 100 | ||
102 | void lcd_remote_off(void) | 101 | void lcd_remote_off(void) |
103 | { | 102 | { |
104 | remote_power&=~(0x80); | 103 | remote_power&=~(0x80); |
105 | remote_state_control=REMOTE_CONTROL_POWER; | 104 | remote_state_control_next=REMOTE_CONTROL_POWER; |
106 | } | 105 | } |
107 | 106 | ||
108 | unsigned char lcd_remote_test[16]= | 107 | /* This is the maximum transfer size to the remote (op 0x51= 7 bytes setup+79 |
109 | {0x80,0xFF,0x80,0x00,0xFF,0x89,0x89,0x00,0xC1,0x89,0x8F,0x80,0xFF,0x80,0,0}; | 108 | * bytes screen data+xor+sum |
109 | */ | ||
110 | unsigned char remote_payload[88]; | ||
111 | unsigned char remote_payload_size; | ||
112 | bool remote_repeat_draw=false; | ||
113 | |||
114 | unsigned char remote_draw_x, remote_draw_y, | ||
115 | remote_draw_width, remote_draw_height; | ||
110 | 116 | ||
111 | /* Monitor remote hotswap */ | 117 | /* Monitor remote hotswap */ |
112 | static void remote_tick(void) | 118 | static void remote_tick(void) |
113 | { | 119 | { |
114 | unsigned char i; | 120 | unsigned char i; |
115 | unsigned char remote_payload[10], remote_payload_size; | 121 | static unsigned char pause_length=0; |
116 | unsigned char remote_check_xor, remote_check_sum; | 122 | |
123 | if(remote_state_control!=REMOTE_CONTROL_DRAW) | ||
124 | remote_state_control=remote_state_control_next; | ||
117 | 125 | ||
118 | switch (remote_state_control) | 126 | switch (remote_state_control) |
119 | { | 127 | { |
120 | case REMOTE_CONTROL_IDLE: | 128 | case REMOTE_CONTROL_IDLE: |
121 | |||
122 | remote_payload_size=0; | 129 | remote_payload_size=0; |
123 | remote_state_control=REMOTE_CONTROL_IDLE; | 130 | remote_state_control=REMOTE_CONTROL_IDLE; |
124 | break; | 131 | break; |
132 | |||
125 | case REMOTE_CONTROL_NOP: | 133 | case REMOTE_CONTROL_NOP: |
126 | remote_payload[0]=0x11; | 134 | remote_payload[0]=0x11; |
127 | remote_payload[1]=0x30; | 135 | remote_payload[1]=0x30; |
@@ -129,6 +137,7 @@ static void remote_tick(void) | |||
129 | remote_payload_size=2; | 137 | remote_payload_size=2; |
130 | remote_state_control=REMOTE_CONTROL_NOP; | 138 | remote_state_control=REMOTE_CONTROL_NOP; |
131 | break; | 139 | break; |
140 | |||
132 | case REMOTE_CONTROL_POWER: | 141 | case REMOTE_CONTROL_POWER: |
133 | remote_payload[0]=0x31; | 142 | remote_payload[0]=0x31; |
134 | remote_payload[1]=remote_power; | 143 | remote_payload[1]=remote_power; |
@@ -137,51 +146,65 @@ static void remote_tick(void) | |||
137 | remote_payload_size=3; | 146 | remote_payload_size=3; |
138 | remote_state_control=REMOTE_CONTROL_NOP; | 147 | remote_state_control=REMOTE_CONTROL_NOP; |
139 | break; | 148 | break; |
149 | |||
140 | case REMOTE_CONTROL_MASK: | 150 | case REMOTE_CONTROL_MASK: |
141 | remote_payload[0]=0x41; | 151 | remote_payload[0]=0x41; |
142 | remote_payload[1]=0x94; | 152 | remote_payload[1]=remote_mask; |
143 | 153 | ||
144 | remote_payload_size=2; | 154 | remote_payload_size=2; |
145 | remote_state_control=REMOTE_CONTROL_NOP; | 155 | remote_state_control=REMOTE_CONTROL_NOP; |
146 | break; | 156 | break; |
147 | case REMOTE_CONTROL_DRAW1: | ||
148 | remote_payload[0]=0x51; | ||
149 | remote_payload[1]=0x80; | ||
150 | remote_payload[2]=14; | ||
151 | remote_payload[3]=0; | ||
152 | remote_payload[4]=0; | ||
153 | remote_payload[5]=14; | ||
154 | remote_payload[6]=8; | ||
155 | |||
156 | remote_payload_size=7; | ||
157 | remote_state_control=REMOTE_CONTROL_DRAW_PAUSE1; | ||
158 | break; | ||
159 | case REMOTE_CONTROL_DRAW_PAUSE1: | ||
160 | remote_payload[0]=0x11; | ||
161 | remote_payload[1]=0x30; | ||
162 | 157 | ||
163 | remote_payload_size=2; | 158 | case REMOTE_CONTROL_DRAW: |
164 | remote_state_control=REMOTE_CONTROL_DRAW2; | ||
165 | break; | ||
166 | case REMOTE_CONTROL_DRAW2: | ||
167 | remote_payload[0]=0x51; | 159 | remote_payload[0]=0x51; |
168 | remote_payload[1]=0x80; | 160 | remote_payload[1]=0x80; |
169 | remote_payload[2]=14; | 161 | remote_payload[2]=remote_draw_width; |
170 | remote_payload[3]=0; | 162 | remote_payload[3]=remote_draw_x; |
171 | remote_payload[4]=8; | ||
172 | remote_payload[5]=14; | ||
173 | remote_payload[6]=16; | ||
174 | 163 | ||
175 | remote_payload_size=7; | 164 | remote_payload[5]=remote_draw_x+remote_draw_width; |
176 | remote_state_control=REMOTE_CONTROL_DRAW_PAUSE2; | 165 | remote_payload_size=7+remote_payload[2]; |
177 | break; | ||
178 | case REMOTE_CONTROL_DRAW_PAUSE2: | ||
179 | remote_payload[0]=0x11; | ||
180 | remote_payload[1]=0x30; | ||
181 | 166 | ||
182 | remote_payload_size=2; | 167 | switch (remote_state_draw) |
183 | remote_state_control=REMOTE_CONTROL_NOP; | 168 | { |
169 | case DRAW_TOP: | ||
170 | remote_payload[4]=0; | ||
171 | remote_payload[6]=8; | ||
172 | |||
173 | pause_length=6; | ||
174 | remote_state_draw_next=DRAW_BOTTOM; | ||
175 | remote_state_draw=DRAW_PAUSE; | ||
176 | break; | ||
177 | |||
178 | case DRAW_BOTTOM: | ||
179 | remote_payload[4]=8; | ||
180 | remote_payload[6]=16; | ||
181 | |||
182 | pause_length=6; | ||
183 | remote_state_draw_next=DRAW_TOP; | ||
184 | remote_state_draw=DRAW_PAUSE; | ||
185 | break; | ||
186 | |||
187 | case DRAW_PAUSE: | ||
188 | remote_payload_size=0; | ||
189 | |||
190 | if(--pause_length==0) | ||
191 | { | ||
192 | if(remote_state_draw_next==DRAW_TOP) | ||
193 | remote_state_control=REMOTE_CONTROL_NOP; | ||
194 | |||
195 | remote_state_draw=remote_state_draw_next; | ||
196 | } | ||
197 | else | ||
198 | remote_state_draw=DRAW_PAUSE; | ||
199 | |||
200 | break; | ||
201 | |||
202 | default: | ||
203 | remote_payload_size=0; | ||
204 | break; | ||
205 | } | ||
184 | break; | 206 | break; |
207 | |||
185 | case REMOTE_CONTROL_SLEEP: | 208 | case REMOTE_CONTROL_SLEEP: |
186 | remote_payload[0]=0x71; | 209 | remote_payload[0]=0x71; |
187 | remote_payload[1]=0x30; | 210 | remote_payload[1]=0x30; |
@@ -189,6 +212,7 @@ static void remote_tick(void) | |||
189 | remote_payload_size=2; | 212 | remote_payload_size=2; |
190 | remote_state_control=REMOTE_CONTROL_IDLE; | 213 | remote_state_control=REMOTE_CONTROL_IDLE; |
191 | break; | 214 | break; |
215 | |||
192 | default: | 216 | default: |
193 | remote_payload_size=0; | 217 | remote_payload_size=0; |
194 | break; | 218 | break; |
@@ -199,46 +223,25 @@ static void remote_tick(void) | |||
199 | return; | 223 | return; |
200 | } | 224 | } |
201 | 225 | ||
202 | remote_check_xor=remote_payload[0]; | ||
203 | remote_check_sum=remote_payload[0]; | ||
204 | for(i=1; i<remote_payload_size; i++) | ||
205 | { | ||
206 | remote_check_xor^=remote_payload[i]; | ||
207 | remote_check_sum+=remote_payload[i]; | ||
208 | } | ||
209 | |||
210 | if(remote_payload[0]==0x51) | 226 | if(remote_payload[0]==0x51) |
211 | { | 227 | { |
212 | unsigned char offset; | 228 | for(i=7; i<remote_payload_size; i++) |
213 | unsigned char x; | ||
214 | |||
215 | if(remote_payload[4]==8) | ||
216 | { | ||
217 | offset=79; | ||
218 | } | ||
219 | else | ||
220 | { | ||
221 | offset=0; | ||
222 | } | ||
223 | |||
224 | for (x = 0; x < 14; x++) | ||
225 | { | 229 | { |
226 | remote_check_xor^=lcd_remote_test[x]; | 230 | remote_payload[i]= |
227 | remote_check_sum+=lcd_remote_test[x]; | 231 | lcd_remote_framebuffer[remote_payload[4]>>3][i+remote_draw_x-7]; |
228 | } | 232 | } |
229 | |||
230 | uart1_puts(remote_payload, remote_payload_size); | ||
231 | lcd_remote_test[14]=remote_check_xor; | ||
232 | lcd_remote_test[15]=remote_check_sum; | ||
233 | uart1_puts(lcd_remote_test, 16); | ||
234 | } | 233 | } |
235 | else | ||
236 | { | ||
237 | remote_payload[remote_payload_size]=remote_check_xor; | ||
238 | remote_payload[remote_payload_size+1]=remote_check_sum; | ||
239 | 234 | ||
240 | uart1_puts(remote_payload, remote_payload_size+2); | 235 | /* Calculate the xor and sum to place in the payload */ |
236 | remote_payload[remote_payload_size]=remote_payload[0]; | ||
237 | remote_payload[remote_payload_size+1]=remote_payload[0]; | ||
238 | for(i=1; i<remote_payload_size; i++) | ||
239 | { | ||
240 | remote_payload[remote_payload_size]^=remote_payload[i]; | ||
241 | remote_payload[remote_payload_size+1]+=remote_payload[i]; | ||
241 | } | 242 | } |
243 | |||
244 | uart1_puts(remote_payload, remote_payload_size+2); | ||
242 | } | 245 | } |
243 | 246 | ||
244 | void lcd_remote_init_device(void) | 247 | void lcd_remote_init_device(void) |
@@ -247,6 +250,8 @@ void lcd_remote_init_device(void) | |||
247 | if (remote_detect()) | 250 | if (remote_detect()) |
248 | lcd_remote_on(); | 251 | lcd_remote_on(); |
249 | 252 | ||
253 | lcd_remote_update(); | ||
254 | |||
250 | /* put the remote control in the tick task */ | 255 | /* put the remote control in the tick task */ |
251 | tick_add_task(remote_tick); | 256 | tick_add_task(remote_tick); |
252 | } | 257 | } |
@@ -255,33 +260,28 @@ void lcd_remote_init_device(void) | |||
255 | This must be called after all other LCD functions that change the display. */ | 260 | This must be called after all other LCD functions that change the display. */ |
256 | void lcd_remote_update(void) | 261 | void lcd_remote_update(void) |
257 | { | 262 | { |
258 | if(remote_state_control!=REMOTE_CONTROL_DRAW1 | 263 | lcd_remote_update_rect(0, 0, LCD_REMOTE_WIDTH, LCD_REMOTE_HEIGHT); |
259 | && remote_state_control!=REMOTE_CONTROL_DRAW_PAUSE1 | ||
260 | && remote_state_control!=REMOTE_CONTROL_DRAW2 | ||
261 | && remote_state_control!=REMOTE_CONTROL_DRAW_PAUSE2) | ||
262 | { | ||
263 | remote_state_control=REMOTE_CONTROL_DRAW1; | ||
264 | } | ||
265 | } | 264 | } |
266 | 265 | ||
267 | /* Update a fraction of the display. */ | 266 | /* Update a fraction of the display. */ |
268 | void lcd_remote_update_rect(int x, int y, int width, int height) | 267 | void lcd_remote_update_rect(int x, int y, int width, int height) |
269 | { | 268 | { |
270 | (void)x; | 269 | remote_draw_x=x; |
271 | (void)y; | 270 | remote_draw_y=y; |
272 | (void)width; | 271 | remote_draw_width=width; |
273 | (void)height; | 272 | remote_draw_height=height; |
274 | lcd_remote_update(); | 273 | |
274 | remote_state_control=REMOTE_CONTROL_DRAW; | ||
275 | } | 275 | } |
276 | 276 | ||
277 | void _remote_backlight_on(void) | 277 | void _remote_backlight_on(void) |
278 | { | 278 | { |
279 | remote_power|=0x40; | 279 | remote_power|=0x40; |
280 | remote_state_control=REMOTE_CONTROL_POWER; | 280 | remote_state_control_next=REMOTE_CONTROL_POWER; |
281 | } | 281 | } |
282 | 282 | ||
283 | void _remote_backlight_off(void) | 283 | void _remote_backlight_off(void) |
284 | { | 284 | { |
285 | remote_power&=~(0x40); | 285 | remote_power&=~(0x40); |
286 | remote_state_control=REMOTE_CONTROL_POWER; | 286 | remote_state_control_next=REMOTE_CONTROL_POWER; |
287 | } | 287 | } |
diff --git a/firmware/target/arm/tms320dm320/uart-dm320.c b/firmware/target/arm/tms320dm320/uart-dm320.c index 5e2ad5e2be..d68beb6e01 100644 --- a/firmware/target/arm/tms320dm320/uart-dm320.c +++ b/firmware/target/arm/tms320dm320/uart-dm320.c | |||
@@ -27,37 +27,48 @@ | |||
27 | 27 | ||
28 | #define MAX_UART_BUFFER 31 | 28 | #define MAX_UART_BUFFER 31 |
29 | #define SEND_RING_SIZE 256 | 29 | #define SEND_RING_SIZE 256 |
30 | #define RECIEVE_RING_SIZE 20 | 30 | #define RECEIVE_RING_SIZE 20 |
31 | 31 | ||
32 | char | 32 | char |
33 | // uart1_send_buffer_ring[SEND_RING_SIZE], | 33 | uart1_send_buffer_ring[SEND_RING_SIZE], |
34 | uart1_recieve_buffer_ring[RECIEVE_RING_SIZE]; | 34 | uart1_receive_buffer_ring[RECEIVE_RING_SIZE]; |
35 | 35 | ||
36 | //static unsigned int uart1_send_count, uart1_send_read, uart1_send_write; | 36 | static volatile int uart1_send_count, uart1_send_read, uart1_send_write; |
37 | static unsigned int uart1_recieve_count, uart1_recieve_read, uart1_recieve_write; | 37 | static volatile int uart1_receive_count, uart1_receive_read, uart1_receive_write; |
38 | 38 | ||
39 | void uart_init(void) | 39 | void uart_init(void) |
40 | { | 40 | { |
41 | // 8-N-1 | 41 | // 8-N-1 |
42 | IO_UART1_MSR = 0x8000; | 42 | IO_UART1_MSR = 0xC400; |
43 | IO_UART1_BRSR = 0x0057; | 43 | IO_UART1_BRSR = 0x0057; |
44 | IO_UART1_RFCR = 0x8010; /* Trigger later */ | 44 | IO_UART1_RFCR = 0x8020; /* Trigger later */ |
45 | IO_UART1_TFCR = 0x0000; /* Trigger level */ | ||
45 | /* gio 27 is input, uart1 rx | 46 | /* gio 27 is input, uart1 rx |
46 | gio 28 is output, uart1 tx */ | 47 | gio 28 is output, uart1 tx */ |
47 | IO_GIO_DIR1 |= (1<<11); /* gio 27 */ | 48 | IO_GIO_DIR1 |= (1<<11); /* gio 27 */ |
48 | IO_GIO_DIR1 &= ~(1<<12); /* gio 28 */ | 49 | IO_GIO_DIR1 &= ~(1<<12); /* gio 28 */ |
49 | 50 | ||
50 | /* init the recieve buffer */ | 51 | /* init the receive buffer */ |
51 | uart1_recieve_count=0; | 52 | uart1_receive_count=0; |
52 | uart1_recieve_read=0; | 53 | uart1_receive_read=0; |
53 | uart1_recieve_write=0; | 54 | uart1_receive_write=0; |
55 | |||
56 | /* init the send buffer */ | ||
57 | uart1_send_count=0; | ||
58 | uart1_send_read=0; | ||
59 | uart1_send_write=0; | ||
54 | 60 | ||
55 | /* Enable the interrupt */ | 61 | /* Enable the interrupt */ |
56 | IO_INTC_EINT0 |= INTR_EINT0_UART1; | 62 | IO_INTC_EINT0 |= INTR_EINT0_UART1; |
57 | } | 63 | } |
58 | 64 | ||
65 | |||
66 | /* This function is not interrupt driven */ | ||
59 | void uart1_putc(char ch) | 67 | void uart1_putc(char ch) |
60 | { | 68 | { |
69 | /* Wait for the interupt driven puts to finish */ | ||
70 | while(uart1_send_count>0); | ||
71 | |||
61 | /* Wait for room in FIFO */ | 72 | /* Wait for room in FIFO */ |
62 | while ((IO_UART1_TFCR & 0x3f) >= 0x20); | 73 | while ((IO_UART1_TFCR & 0x3f) >= 0x20); |
63 | 74 | ||
@@ -67,45 +78,73 @@ void uart1_putc(char ch) | |||
67 | 78 | ||
68 | void uart1_puts(const char *str, int size) | 79 | void uart1_puts(const char *str, int size) |
69 | { | 80 | { |
70 | int count=0; | 81 | if(size>SEND_RING_SIZE) |
71 | while (count<size) | 82 | panicf("Too much data passed to uart1_puts"); |
83 | |||
84 | /* Wait for the previous transfer to finish */ | ||
85 | while(uart1_send_count>0); | ||
86 | |||
87 | memcpy(uart1_send_buffer_ring, str, size); | ||
88 | |||
89 | /* Disable interrupt while modifying the pointers */ | ||
90 | IO_INTC_EINT0 &= ~INTR_EINT0_UART1; | ||
91 | |||
92 | uart1_send_count=size; | ||
93 | uart1_send_read=0; | ||
94 | |||
95 | /* prime the hardware buffer */ | ||
96 | while(((IO_UART1_TFCR & 0x3f) < 0x20) && (uart1_send_count > 0)) | ||
72 | { | 97 | { |
73 | uart1_putc(str[count]); | 98 | IO_UART1_DTRR=uart1_send_buffer_ring[uart1_send_read++]; |
74 | count++; | 99 | uart1_send_count--; |
75 | } | 100 | } |
101 | |||
102 | /* Enable interrupt */ | ||
103 | IO_INTC_EINT0 |= INTR_EINT0_UART1; | ||
104 | } | ||
105 | |||
106 | void uart1_clear_queue(void) | ||
107 | { | ||
108 | /* Disable interrupt while modifying the pointers */ | ||
109 | IO_INTC_EINT0 &= ~INTR_EINT0_UART1; | ||
110 | uart1_receive_write=0; | ||
111 | uart1_receive_count=0; | ||
112 | uart1_receive_read=0; | ||
113 | /* Enable interrupt */ | ||
114 | IO_INTC_EINT0 |= INTR_EINT0_UART1; | ||
76 | } | 115 | } |
77 | 116 | ||
78 | /* This function returns the number of bytes left in the queue after a read is done (negative if fail)*/ | 117 | /* This function returns the number of bytes left in the queue after a read is done (negative if fail)*/ |
79 | int uart1_gets_queue(char *str, unsigned int size) | 118 | int uart1_gets_queue(char *str, int size) |
80 | { | 119 | { |
120 | /* Disable the interrupt while modifying the pointers */ | ||
81 | IO_INTC_EINT0 &= ~INTR_EINT0_UART1; | 121 | IO_INTC_EINT0 &= ~INTR_EINT0_UART1; |
82 | int retval; | 122 | int retval; |
83 | 123 | ||
84 | if(uart1_recieve_count<size) | 124 | if(uart1_receive_count<size) |
85 | { | 125 | { |
86 | retval= -1; | 126 | retval= -1; |
87 | } | 127 | } |
88 | else | 128 | else |
89 | { | 129 | { |
90 | if(uart1_recieve_read+size<RECIEVE_RING_SIZE) | 130 | if(uart1_receive_read+size<=RECEIVE_RING_SIZE) |
91 | { | 131 | { |
92 | memcpy(str,uart1_recieve_buffer_ring+uart1_recieve_read,size); | 132 | memcpy(str,uart1_receive_buffer_ring+uart1_receive_read,size); |
133 | |||
134 | uart1_receive_read+=size; | ||
93 | } | 135 | } |
94 | else | 136 | else |
95 | { | 137 | { |
96 | int tempcount=(RECIEVE_RING_SIZE-uart1_recieve_read); | 138 | int tempcount=(RECEIVE_RING_SIZE-uart1_receive_read); |
97 | memcpy(str,uart1_recieve_buffer_ring+uart1_recieve_read,tempcount); | 139 | memcpy(str,uart1_receive_buffer_ring+uart1_receive_read,tempcount); |
98 | memcpy(str+tempcount,uart1_recieve_buffer_ring,size-tempcount); | 140 | memcpy(str+tempcount,uart1_receive_buffer_ring,size-tempcount); |
141 | |||
142 | uart1_receive_read=size-tempcount; | ||
99 | } | 143 | } |
100 | 144 | ||
101 | uart1_recieve_count-=size; | 145 | uart1_receive_count-=size; |
102 | 146 | ||
103 | if(uart1_recieve_read+size<RECIEVE_RING_SIZE) | 147 | retval=uart1_receive_count; |
104 | uart1_recieve_read+=size; | ||
105 | else | ||
106 | uart1_recieve_read=size-(RECIEVE_RING_SIZE-uart1_recieve_read); | ||
107 | |||
108 | retval=uart1_recieve_count; | ||
109 | } | 148 | } |
110 | 149 | ||
111 | /* Enable the interrupt */ | 150 | /* Enable the interrupt */ |
@@ -114,23 +153,29 @@ int uart1_gets_queue(char *str, unsigned int size) | |||
114 | return retval; | 153 | return retval; |
115 | } | 154 | } |
116 | 155 | ||
117 | /* UART1 receive interupt handler */ | 156 | /* UART1 receive/transmit interupt handler */ |
118 | void UART1(void) | 157 | void UART1(void) |
119 | { | 158 | { |
120 | while (IO_UART1_RFCR & 0x3f) | 159 | while (IO_UART1_RFCR & 0x3f) |
121 | { | 160 | { |
122 | if (uart1_recieve_count > RECIEVE_RING_SIZE) | 161 | if (uart1_receive_count > RECEIVE_RING_SIZE) |
123 | panicf("UART1 buffer overflow"); | 162 | panicf("UART1 receive buffer overflow"); |
124 | else | 163 | else |
125 | { | 164 | { |
126 | if(uart1_recieve_write>=RECIEVE_RING_SIZE) | 165 | if(uart1_receive_write>=RECEIVE_RING_SIZE) |
127 | uart1_recieve_write=0; | 166 | uart1_receive_write=0; |
128 | 167 | ||
129 | uart1_recieve_buffer_ring[uart1_recieve_write] = IO_UART1_DTRR & 0xff; | 168 | uart1_receive_buffer_ring[uart1_receive_write]=IO_UART1_DTRR & 0xff; |
130 | uart1_recieve_write++; | 169 | uart1_receive_write++; |
131 | uart1_recieve_count++; | 170 | uart1_receive_count++; |
132 | } | 171 | } |
133 | } | 172 | } |
134 | 173 | ||
174 | while ( ((IO_UART1_TFCR & 0x3f) < 0x20) && (uart1_send_count > 0) ) | ||
175 | { | ||
176 | IO_UART1_DTRR=uart1_send_buffer_ring[uart1_send_read++]; | ||
177 | uart1_send_count--; | ||
178 | } | ||
179 | |||
135 | IO_INTC_IRQ0 = INTR_IRQ0_UART1; | 180 | IO_INTC_IRQ0 = INTR_IRQ0_UART1; |
136 | } | 181 | } |
diff --git a/firmware/target/arm/tms320dm320/uart-target.h b/firmware/target/arm/tms320dm320/uart-target.h index 68145b8358..9be9ba51fe 100644 --- a/firmware/target/arm/tms320dm320/uart-target.h +++ b/firmware/target/arm/tms320dm320/uart-target.h | |||
@@ -23,10 +23,10 @@ | |||
23 | void uart_init(void); | 23 | void uart_init(void); |
24 | bool uart1_available(void); | 24 | bool uart1_available(void); |
25 | 25 | ||
26 | int uart1_gets_queue(char *, unsigned int); | 26 | int uart1_gets_queue(char *, int); |
27 | void uart1_puts(const char *str, int size); | 27 | void uart1_puts(const char *str, int size); |
28 | void uart1_gets(char *str, unsigned int size); | 28 | void uart1_gets(char *str, int size); |
29 | void uart1_putc(char ch); | 29 | void uart1_putc(char ch); |
30 | 30 | ||
31 | 31 | void uart1_clear_queue(void); | |
32 | #endif | 32 | #endif |