]> git.gag.com Git - fw/altos/blob - src/stmf0/ao_usb_stm.c
drivers: Add BMI088 driver
[fw/altos] / src / stmf0 / ao_usb_stm.c
1 /*
2  * Copyright © 2012 Keith Packard <keithp@keithp.com>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
17  */
18
19 #include "ao.h"
20 #include "ao_usb.h"
21 #include "ao_product.h"
22 #include "ao_power.h"
23
24 #define USB_DEBUG       0
25 #define USB_STATUS      0
26 #define USB_DEBUG_DATA  0
27 #define USB_ECHO        0
28
29 #ifndef AO_PA11_PA12_RMP
30 #error "must define AO_PA11_PA12_RMP"
31 #endif
32
33 #ifndef AO_POWER_MANAGEMENT
34 #define AO_POWER_MANAGEMENT     0
35 #endif
36
37 #ifndef USE_USB_STDIO
38 #define USE_USB_STDIO   1
39 #endif
40
41 #if USE_USB_STDIO
42 #define AO_USB_OUT_SLEEP_ADDR   (&ao_stdin_ready)
43 #else
44 #define AO_USB_OUT_SLEEP_ADDR   (&ao_usb_out_avail)
45 #endif
46
47 #if USB_DEBUG
48 #define debug(format, args...)  printf(format, ## args);
49 #else
50 #define debug(format, args...)
51 #endif
52
53 #if USB_DEBUG_DATA
54 #define debug_data(format, args...)     printf(format, ## args);
55 #else
56 #define debug_data(format, args...)
57 #endif
58
59 struct ao_usb_setup {
60         uint8_t         dir_type_recip;
61         uint8_t         request;
62         uint16_t        value;
63         uint16_t        index;
64         uint16_t        length;
65 } ao_usb_setup;
66
67 static uint8_t  ao_usb_ep0_state;
68
69 /* Pending EP0 IN data */
70 static const uint8_t    *ao_usb_ep0_in_data;    /* Remaining data */
71 static uint8_t          ao_usb_ep0_in_len;      /* Remaining amount */
72
73 /* Temp buffer for smaller EP0 in data */
74 static uint8_t  ao_usb_ep0_in_buf[2];
75
76 /* Pending EP0 OUT data */
77 static uint8_t *ao_usb_ep0_out_data;
78 static uint8_t  ao_usb_ep0_out_len;
79
80 /*
81  * Objects allocated in special USB memory
82  */
83
84 /* Buffer description tables */
85
86 #define ao_usb_bdt      ((union stm_usb_bdt *) (intptr_t) (void *) stm_usb_sram)
87
88 /* Pointer to ep0 tx/rx buffers in USB memory */
89 static uint16_t ao_usb_ep0_tx_offset;
90 static uint16_t ao_usb_ep0_rx_offset;
91
92 #if AO_USB_HAS_INT
93 /* Pointer to interrupt buffer in USB memory */
94 static uint16_t ao_usb_int_tx_offset;
95 #endif
96
97 /* Pointer to bulk data tx/rx buffers in USB memory */
98 #if AO_USB_HAS_IN
99 static uint16_t ao_usb_in_tx_offset;
100 static uint8_t  ao_usb_in_tx_which;
101 static uint8_t  ao_usb_tx_count;
102
103 #endif
104 #if AO_USB_HAS_OUT
105 static uint16_t ao_usb_out_rx_offset;
106 static uint8_t  ao_usb_out_rx_which;
107 static uint8_t  ao_usb_rx_count, ao_usb_rx_pos;
108
109 #endif
110 #if AO_USB_HAS_IN2
111 static uint16_t ao_usb_in_tx2_offset;
112 static uint8_t  ao_usb_in_tx2_which;
113 static uint8_t  ao_usb_tx2_count;
114 #endif
115
116 #if AO_USB_HAS_IN3
117 static uint16_t ao_usb_in_tx3_offset;
118 static uint8_t  ao_usb_in_tx3_which;
119 static uint8_t  ao_usb_tx3_count;
120 #endif
121
122 /*
123  * End point register indices
124  */
125
126 #define AO_USB_CONTROL_EPR      0
127 #define AO_USB_INT_EPR          1
128 #define AO_USB_OUT_EPR          2
129 #define AO_USB_IN_EPR           3
130 #define AO_USB_IN2_EPR          4
131 #define AO_USB_IN3_EPR          5
132
133 /* Marks when we don't need to send an IN packet.
134  * This happens only when the last IN packet is not full,
135  * otherwise the host will expect to keep seeing packets.
136  * Send a zero-length packet as required
137  */
138 static uint8_t  ao_usb_in_flushed;
139
140 /* Marks when we have delivered an IN packet to the hardware
141  * and it has not been received yet. ao_sleep on this address
142  * to wait for it to be delivered.
143  */
144 static uint8_t  ao_usb_in_pending;
145
146 #if AO_USB_HAS_IN2
147 /* Marks when we have delivered an IN packet to the hardware
148  * and it has not been received yet. ao_sleep on this address
149  * to wait for it to be delivered.
150  */
151 static uint8_t  ao_usb_in2_pending;
152 static uint16_t in2_count;
153 static uint8_t  ao_usb_in2_flushed;
154 #endif
155
156 #if AO_USB_HAS_IN3
157 /* Marks when we have delivered an IN packet to the hardware
158  * and it has not been received yet. ao_sleep on this address
159  * to wait for it to be delivered.
160  */
161 static uint8_t  ao_usb_in3_pending;
162 static uint16_t in3_count;
163 static uint8_t  ao_usb_in3_flushed;
164 #endif
165
166 /* Marks when an OUT packet has been received by the hardware
167  * but not pulled to the shadow buffer.
168  */
169 static uint8_t  ao_usb_out_avail;
170 uint8_t         ao_usb_running;
171 static uint8_t  ao_usb_configuration;
172
173 #define AO_USB_EP0_GOT_SETUP    1
174 #define AO_USB_EP0_GOT_RX_DATA  2
175 #define AO_USB_EP0_GOT_TX_ACK   4
176
177 static uint8_t  ao_usb_ep0_receive;
178 static uint8_t  ao_usb_address;
179 static uint8_t  ao_usb_address_pending;
180
181 static inline uint32_t set_toggle(uint32_t      current_value,
182                                    uint32_t     mask,
183                                    uint32_t     desired_value)
184 {
185         return (current_value ^ desired_value) & mask;
186 }
187
188 static inline uint16_t *ao_usb_packet_buffer_addr(uint16_t sram_addr)
189 {
190         return (uint16_t *) (void *) (stm_usb_sram + sram_addr);
191 }
192
193 static inline uint16_t ao_usb_packet_get(uint16_t sram_addr)
194 {
195         return ao_usb_packet_buffer_addr(sram_addr)[0];
196 }
197
198 static inline void ao_usb_packet_put(uint16_t sram_addr, uint16_t val)
199 {
200         ao_usb_packet_buffer_addr(sram_addr)[0] = val;
201 }
202
203 static inline uint16_t ao_usb_packet_buffer_offset(uint16_t *addr)
204 {
205         return (uint16_t) ((uint8_t *) addr - stm_usb_sram);
206 }
207
208 static inline uint32_t ao_usb_epr_stat_rx(uint32_t epr) {
209         return (epr >> STM_USB_EPR_STAT_RX) & STM_USB_EPR_STAT_RX_MASK;
210 }
211
212 static inline uint32_t ao_usb_epr_stat_tx(uint32_t epr) {
213         return (epr >> STM_USB_EPR_STAT_TX) & STM_USB_EPR_STAT_TX_MASK;
214 }
215
216 static inline uint32_t ao_usb_epr_ctr_rx(uint32_t epr) {
217         return (epr >> STM_USB_EPR_CTR_RX) & 1;
218 }
219
220 static inline uint32_t ao_usb_epr_ctr_tx(uint32_t epr) {
221         return (epr >> STM_USB_EPR_CTR_TX) & 1;
222 }
223
224 static inline uint32_t ao_usb_epr_setup(uint32_t epr) {
225         return (epr >> STM_USB_EPR_SETUP) & 1;
226 }
227
228 static inline uint32_t ao_usb_epr_dtog_rx(uint32_t epr) {
229         return (epr >> STM_USB_EPR_DTOG_RX) & 1;
230 }
231
232 static inline uint32_t ao_usb_epr_sw_buf_tx(uint32_t epr) {
233         return (epr >> STM_USB_EPR_SW_BUF_TX) & 1;
234 }
235
236 static inline uint32_t ao_usb_epr_dtog_tx(uint32_t epr) {
237         return (epr >> STM_USB_EPR_DTOG_TX) & 1;
238 }
239
240 static inline uint32_t ao_usb_epr_sw_buf_rx(uint32_t epr) {
241         return (epr >> STM_USB_EPR_SW_BUF_RX) & 1;
242 }
243
244 /*
245  * Set current device address and mark the
246  * interface as active
247  */
248 static void
249 ao_usb_set_address(uint8_t address)
250 {
251         debug("ao_usb_set_address %02x\n", address);
252         stm_usb.daddr = (1 << STM_USB_DADDR_EF) | address;
253         ao_usb_address_pending = 0;
254 }
255
256 /*
257  * Write these values to preserve register contents under HW changes
258  */
259
260 #define STM_USB_EPR_INVARIANT   ((1 << STM_USB_EPR_CTR_RX) |            \
261                                  (STM_USB_EPR_DTOG_RX_WRITE_INVARIANT << STM_USB_EPR_DTOG_RX) | \
262                                  (STM_USB_EPR_STAT_RX_WRITE_INVARIANT << STM_USB_EPR_STAT_RX) | \
263                                  (1 << STM_USB_EPR_CTR_TX) |            \
264                                  (STM_USB_EPR_DTOG_TX_WRITE_INVARIANT << STM_USB_EPR_DTOG_TX) | \
265                                  (STM_USB_EPR_STAT_TX_WRITE_INVARIANT << STM_USB_EPR_STAT_TX))
266
267 #define STM_USB_EPR_INVARIANT_MASK      ((1 << STM_USB_EPR_CTR_RX) |    \
268                                          (STM_USB_EPR_DTOG_RX_MASK << STM_USB_EPR_DTOG_RX) | \
269                                          (STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX) | \
270                                          (1 << STM_USB_EPR_CTR_TX) |    \
271                                          (STM_USB_EPR_DTOG_TX_MASK << STM_USB_EPR_DTOG_TX) | \
272                                          (STM_USB_EPR_STAT_TX_MASK << STM_USB_EPR_STAT_TX))
273
274 /*
275  * These bits are purely under sw control, so preserve them in the
276  * register by re-writing what was read
277  */
278 #define STM_USB_EPR_PRESERVE_MASK       ((STM_USB_EPR_EP_TYPE_MASK << STM_USB_EPR_EP_TYPE) | \
279                                          (1 << STM_USB_EPR_EP_KIND) |   \
280                                          (STM_USB_EPR_EA_MASK << STM_USB_EPR_EA))
281
282 #define TX_DBG 0
283 #define RX_DBG 0
284
285 #if TX_DBG
286 #define _tx_dbg0(msg) _dbg(__LINE__,msg,0)
287 #define _tx_dbg1(msg,value) _dbg(__LINE__,msg,value)
288 #else
289 #define _tx_dbg0(msg)
290 #define _tx_dbg1(msg,value)
291 #endif
292
293 #if RX_DBG
294 #define _rx_dbg0(msg) _dbg(__LINE__,msg,0)
295 #define _rx_dbg1(msg,value) _dbg(__LINE__,msg,value)
296 #else
297 #define _rx_dbg0(msg)
298 #define _rx_dbg1(msg,value)
299 #endif
300
301 #if TX_DBG || RX_DBG
302 static void _dbg(int line, char *msg, uint32_t value);
303 #endif
304
305 /*
306  * Set the state of the specified endpoint register to a new
307  * value. This is tricky because the bits toggle where the new
308  * value is one, and we need to write invariant values in other
309  * spots of the register. This hardware is strange...
310  */
311 static void
312 _ao_usb_set_stat_tx(int ep, uint32_t stat_tx)
313 {
314         uint16_t        epr_write, epr_old;
315
316         _tx_dbg1("set_stat_tx top", stat_tx);
317         epr_old = epr_write = stm_usb.epr[ep].r;
318         epr_write &= STM_USB_EPR_PRESERVE_MASK;
319         epr_write |= STM_USB_EPR_INVARIANT;
320         epr_write |= (uint16_t) set_toggle(epr_old,
321                                            STM_USB_EPR_STAT_TX_MASK << STM_USB_EPR_STAT_TX,
322                                            stat_tx << STM_USB_EPR_STAT_TX);
323         stm_usb.epr[ep].r = epr_write;
324         _tx_dbg1("set_stat_tx bottom", epr_write);
325 }
326
327 static void
328 ao_usb_set_stat_tx(int ep, uint32_t stat_tx)
329 {
330         ao_arch_block_interrupts();
331         _ao_usb_set_stat_tx(ep, stat_tx);
332         ao_arch_release_interrupts();
333 }
334
335 static void
336 _ao_usb_toggle_dtog(int ep, uint32_t dtog_rx, uint32_t dtog_tx)
337 {
338         uint16_t        epr_write;
339
340         _tx_dbg1("toggle_dtog top", dtog_rx);
341         epr_write = stm_usb.epr[ep].r;
342         epr_write &= STM_USB_EPR_PRESERVE_MASK;
343         epr_write |= STM_USB_EPR_INVARIANT;
344         epr_write |= (uint16_t) ((dtog_rx << STM_USB_EPR_DTOG_RX) |
345                                  (dtog_tx << STM_USB_EPR_DTOG_TX));
346         stm_usb.epr[ep].r = epr_write;
347         _tx_dbg1("toggle_dtog bottom", epr_write);
348 }
349
350 static void
351 _ao_usb_set_stat_rx(int ep, uint32_t stat_rx) {
352         uint16_t        epr_write, epr_old;
353
354         epr_write = epr_old = stm_usb.epr[ep].r;
355         epr_write &= STM_USB_EPR_PRESERVE_MASK;
356         epr_write |= STM_USB_EPR_INVARIANT;
357         epr_write |= (uint16_t) set_toggle(epr_old,
358                                            STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX,
359                                            stat_rx << STM_USB_EPR_STAT_RX);
360         stm_usb.epr[ep].r = epr_write;
361 }
362
363 static void
364 ao_usb_set_stat_rx(int ep, uint32_t stat_rx) {
365         ao_arch_block_interrupts();
366         _ao_usb_set_stat_rx(ep, stat_rx);
367         ao_arch_release_interrupts();
368 }
369
370 /*
371  * Initialize an entpoint
372  */
373
374 static void
375 ao_usb_init_ep(uint8_t ep, uint16_t addr, uint16_t type,
376                uint16_t stat_rx, uint16_t stat_tx,
377                uint16_t kind,
378                uint16_t dtog_rx, uint16_t dtog_tx)
379 {
380         uint16_t                epr;
381
382         ao_arch_block_interrupts();
383         epr = stm_usb.epr[ep].r;
384         epr = (uint16_t) ((0UL << STM_USB_EPR_CTR_RX) |
385                           ((uint32_t) type << STM_USB_EPR_EP_TYPE) |
386                           ((uint32_t) kind << STM_USB_EPR_EP_KIND) |
387                           (0UL << STM_USB_EPR_CTR_TX) |
388                           ((uint32_t) addr << STM_USB_EPR_EA) |
389                           set_toggle(epr,
390
391                                      (1UL << STM_USB_EPR_DTOG_RX) |
392                                      (STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX) |
393                                      (1UL << STM_USB_EPR_DTOG_TX) |
394                                      (STM_USB_EPR_STAT_TX_MASK << STM_USB_EPR_STAT_TX),
395
396                                      ((uint32_t) dtog_rx << STM_USB_EPR_DTOG_RX) |
397                                      ((uint32_t) stat_rx << STM_USB_EPR_STAT_RX) |
398                                      ((uint32_t) dtog_tx << STM_USB_EPR_DTOG_TX) |
399                                      ((uint32_t) stat_tx << STM_USB_EPR_STAT_TX)));
400         stm_usb.epr[ep].r = epr;
401         ao_arch_release_interrupts();
402         debug ("writing epr[%d] 0x%04x wrote 0x%04x\n",
403                ep, epr, stm_usb.epr[ep].r);
404 }
405
406 static void
407 ao_usb_alloc_buffers(void)
408 {
409         uint16_t sram_addr = 0;
410
411         /* allocate space for BDT, which is at the start of SRAM */
412         sram_addr += 8 * STM_USB_BDT_SIZE;
413
414         ao_usb_ep0_tx_offset = sram_addr;
415         sram_addr += AO_USB_CONTROL_SIZE;
416
417         ao_usb_ep0_rx_offset = sram_addr;
418         sram_addr += AO_USB_CONTROL_SIZE;
419
420 #if AO_USB_HAS_INT
421         sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1));
422         ao_usb_int_tx_offset = sram_addr;
423         sram_addr += AO_USB_INT_SIZE;
424 #endif
425
426 #if AO_USB_HAS_OUT
427         sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1));
428         ao_usb_out_rx_offset = sram_addr;
429         sram_addr += AO_USB_OUT_SIZE * 2;
430 #endif
431
432 #if AO_USB_HAS_IN
433         sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1));
434         ao_usb_in_tx_offset = sram_addr;
435         sram_addr += AO_USB_IN_SIZE * 2;
436 #endif
437
438 #if AO_USB_HAS_IN2
439         sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1));
440         ao_usb_in_tx2_offset = sram_addr;
441         sram_addr += AO_USB_IN_SIZE * 2;
442 #endif
443 #if AO_USB_HAS_IN3
444         sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1));
445         ao_usb_in_tx3_offset = sram_addr;
446         sram_addr += AO_USB_IN_SIZE * 2;
447 #endif
448 }
449
450 static void
451 ao_usb_init_btable(void)
452 {
453         /* Set up EP 0 - a Control end point with 32 bytes of in and out buffers */
454
455         stm_usb_bdt[0].single.addr_tx = ao_usb_ep0_tx_offset;
456         stm_usb_bdt[0].single.count_tx = 0;
457
458         stm_usb_bdt[0].single.addr_rx = ao_usb_ep0_rx_offset;
459         stm_usb_bdt[0].single.count_rx = ((1 << STM_USB_BDT_COUNT_RX_BL_SIZE) |
460                                   (((AO_USB_CONTROL_SIZE / 32) - 1) << STM_USB_BDT_COUNT_RX_NUM_BLOCK));
461 }
462
463 static void
464 ao_usb_set_ep0(void)
465 {
466         uint8_t e;
467
468         ao_usb_init_btable();
469
470         /* buffer table is at the start of USB memory */
471         stm_usb.btable = 0;
472
473         ao_usb_init_ep(AO_USB_CONTROL_EPR, AO_USB_CONTROL_EP,
474                        STM_USB_EPR_EP_TYPE_CONTROL,
475                        STM_USB_EPR_STAT_RX_VALID,
476                        STM_USB_EPR_STAT_TX_NAK,
477                        STM_USB_EPR_EP_KIND_NO_STATUS_OUT, 0, 0);
478
479         /* Clear all of the other endpoints */
480         for (e = 1; e < 8; e++) {
481                 ao_usb_init_ep(e, 0,
482                                STM_USB_EPR_EP_TYPE_CONTROL,
483                                STM_USB_EPR_STAT_RX_DISABLED,
484                                STM_USB_EPR_STAT_TX_DISABLED,
485                                STM_USB_EPR_EP_KIND_SNGL_BUF, 0, 0);
486         }
487
488         ao_usb_set_address(0);
489
490         ao_usb_running = 0;
491
492         /* Reset our internal state
493          */
494
495         ao_usb_ep0_state = AO_USB_EP0_IDLE;
496
497         ao_usb_ep0_in_data = NULL;
498         ao_usb_ep0_in_len = 0;
499
500         ao_usb_ep0_out_data = 0;
501         ao_usb_ep0_out_len = 0;
502 }
503
504 static void
505 ao_usb_set_configuration(void)
506 {
507         debug ("ao_usb_set_configuration\n");
508
509 #if AO_USB_HAS_INT
510         /* Set up the INT end point */
511         stm_usb_bdt[AO_USB_INT_EPR].single.addr_tx = ao_usb_int_tx_offset;
512         stm_usb_bdt[AO_USB_INT_EPR].single.count_tx = 0;
513
514         ao_usb_init_ep(AO_USB_INT_EPR,
515                        AO_USB_INT_EP,
516                        STM_USB_EPR_EP_TYPE_INTERRUPT,
517                        STM_USB_EPR_STAT_RX_DISABLED,
518                        STM_USB_EPR_STAT_TX_NAK,
519                        STM_USB_EPR_EP_KIND_SNGL_BUF, 0, 0);
520 #endif
521
522 #if AO_USB_HAS_OUT
523         /* Set up the OUT end point */
524         stm_usb_bdt[AO_USB_OUT_EPR].double_rx[0].addr = ao_usb_out_rx_offset;
525         stm_usb_bdt[AO_USB_OUT_EPR].double_rx[0].count = ((1 << STM_USB_BDT_COUNT_RX_BL_SIZE) |
526                                                          (((AO_USB_OUT_SIZE / 32) - 1) << STM_USB_BDT_COUNT_RX_NUM_BLOCK));
527
528         stm_usb_bdt[AO_USB_OUT_EPR].double_rx[1].addr = ao_usb_out_rx_offset + AO_USB_OUT_SIZE;
529         stm_usb_bdt[AO_USB_OUT_EPR].double_rx[1].count = ((1 << STM_USB_BDT_COUNT_RX_BL_SIZE) |
530                                                          (((AO_USB_OUT_SIZE / 32) - 1) << STM_USB_BDT_COUNT_RX_NUM_BLOCK));
531
532         /* set 'our' buffer to one, and the device buffer to 0 */
533         ao_usb_init_ep(AO_USB_OUT_EPR,
534                        AO_USB_OUT_EP,
535                        STM_USB_EPR_EP_TYPE_BULK,
536                        STM_USB_EPR_STAT_RX_VALID,
537                        STM_USB_EPR_STAT_TX_DISABLED,
538                        STM_USB_EPR_EP_KIND_DBL_BUF, 0, 1);
539
540         /* At first receive, we'll flip this back to 0 */
541         ao_usb_out_rx_which = 1;
542 #endif
543
544 #if AO_USB_HAS_IN
545         /* Set up the IN end point */
546         stm_usb_bdt[AO_USB_IN_EPR].double_tx[0].addr = ao_usb_in_tx_offset;
547         stm_usb_bdt[AO_USB_IN_EPR].double_tx[0].count = 0;
548         stm_usb_bdt[AO_USB_IN_EPR].double_tx[1].addr = ao_usb_in_tx_offset + AO_USB_IN_SIZE;
549         stm_usb_bdt[AO_USB_IN_EPR].double_tx[1].count = 0;
550
551         /* set 'our' buffer to 0, and the device buffer to 1 */
552         ao_usb_init_ep(AO_USB_IN_EPR,
553                        AO_USB_IN_EP,
554                        STM_USB_EPR_EP_TYPE_BULK,
555                        STM_USB_EPR_STAT_RX_DISABLED,
556                        STM_USB_EPR_STAT_TX_NAK,
557                        STM_USB_EPR_EP_KIND_DBL_BUF,
558                        0, 1);
559
560         /* First transmit data goes to buffer 0 */
561         ao_usb_in_tx_which = 0;
562 #endif
563
564 #if AO_USB_HAS_IN2
565         /* Set up the IN2 end point */
566         stm_usb_bdt[AO_USB_IN2_EPR].double_tx[0].addr = ao_usb_in_tx2_offset;
567         stm_usb_bdt[AO_USB_IN2_EPR].double_tx[0].count = 0;
568         stm_usb_bdt[AO_USB_IN2_EPR].double_tx[1].addr = ao_usb_in_tx2_offset + AO_USB_IN_SIZE;
569         stm_usb_bdt[AO_USB_IN2_EPR].double_tx[1].count = 0;
570
571         ao_usb_init_ep(AO_USB_IN2_EPR,
572                        AO_USB_IN2_EP,
573                        STM_USB_EPR_EP_TYPE_BULK,
574                        STM_USB_EPR_STAT_RX_DISABLED,
575                        STM_USB_EPR_STAT_TX_NAK,
576                        STM_USB_EPR_EP_KIND_DBL_BUF,
577                        0, 1);
578
579         /* First transmit data goes to buffer 0 */
580         ao_usb_in_tx2_which = 0;
581 #endif
582
583 #if AO_USB_HAS_IN3
584         /* Set up the IN3 end point */
585         stm_usb_bdt[AO_USB_IN3_EPR].double_tx[0].addr = ao_usb_in_tx3_offset;
586         stm_usb_bdt[AO_USB_IN3_EPR].double_tx[0].count = 0;
587         stm_usb_bdt[AO_USB_IN3_EPR].double_tx[1].addr = ao_usb_in_tx3_offset + AO_USB_IN_SIZE;
588         stm_usb_bdt[AO_USB_IN3_EPR].double_tx[1].count = 0;
589
590         ao_usb_init_ep(AO_USB_IN3_EPR,
591                        AO_USB_IN3_EP,
592                        STM_USB_EPR_EP_TYPE_BULK,
593                        STM_USB_EPR_STAT_RX_DISABLED,
594                        STM_USB_EPR_STAT_TX_NAK,
595                        STM_USB_EPR_EP_KIND_DBL_BUF,
596                        0, 1);
597
598         /* First transmit data goes to buffer 0 */
599         ao_usb_in_tx3_which = 0;
600 #endif
601
602         ao_usb_in_flushed = 0;
603         ao_usb_in_pending = 0;
604         ao_wakeup(&ao_usb_in_pending);
605 #if AO_USB_HAS_IN2
606         ao_usb_in2_flushed = 0;
607         ao_usb_in2_pending = 0;
608         ao_wakeup(&ao_usb_in2_pending);
609 #endif
610
611 #if AO_USB_HAS_IN3
612         ao_usb_in3_flushed = 0;
613         ao_usb_in3_pending = 0;
614         ao_wakeup(&ao_usb_in3_pending);
615 #endif
616
617         ao_usb_out_avail = 0;
618         ao_usb_configuration = 0;
619
620         ao_wakeup(AO_USB_OUT_SLEEP_ADDR);
621
622         ao_usb_running = 1;
623 #if AO_USB_DIRECTIO
624         ao_wakeup(&ao_usb_running);
625 #endif
626 }
627
628 #if USB_STATUS
629 static uint16_t control_count;
630 static uint16_t int_count;
631 static uint16_t in_count;
632 static uint16_t out_count;
633 static uint16_t reset_count;
634 #endif
635
636 /* The USB memory must be accessed in 16-bit units
637  */
638
639 static void
640 ao_usb_tx_byte(uint16_t offset, uint8_t byte)
641 {
642         if (offset & 1)
643                 ao_usb_packet_put(offset - 1,
644                                   (uint16_t) (ao_usb_packet_get(offset - 1) | ((uint16_t) byte) << 8));
645         else
646                 ao_usb_packet_put(offset, (uint16_t) byte);
647 }
648
649 static uint8_t
650 ao_usb_rx_byte(uint16_t offset)
651 {
652         if (offset & 1)
653                 return (uint8_t) ((ao_usb_packet_get(offset - 1)) >> 8);
654         else
655                 return (uint8_t) ao_usb_packet_get(offset);
656 }
657
658 static void
659 ao_usb_copy_tx(const uint8_t *src, uint16_t offset, uint16_t bytes)
660 {
661         while (bytes--)
662                 ao_usb_tx_byte(offset++, *src++);
663 }
664
665 static void
666 ao_usb_copy_rx(uint8_t *dst, uint16_t offset, uint16_t bytes)
667 {
668         while (bytes--)
669                 *dst++ = ao_usb_rx_byte(offset++);
670 }
671
672 /* Send an IN data packet */
673 static void
674 ao_usb_ep0_flush(void)
675 {
676         uint8_t this_len;
677
678         /* Check to see if the endpoint is still busy */
679         if (ao_usb_epr_stat_tx(stm_usb.epr[0].r) == STM_USB_EPR_STAT_TX_VALID) {
680                 debug("EP0 not accepting IN data\n");
681                 return;
682         }
683
684         this_len = ao_usb_ep0_in_len;
685         if (this_len > AO_USB_CONTROL_SIZE)
686                 this_len = AO_USB_CONTROL_SIZE;
687
688         if (this_len < AO_USB_CONTROL_SIZE)
689                 ao_usb_ep0_state = AO_USB_EP0_IDLE;
690
691         ao_usb_ep0_in_len -= this_len;
692
693         debug_data ("Flush EP0 len %d:", this_len);
694         ao_usb_copy_tx(ao_usb_ep0_in_data, ao_usb_ep0_tx_offset, this_len);
695         debug_data ("\n");
696         ao_usb_ep0_in_data += this_len;
697
698         /* Mark the endpoint as TX valid to send the packet */
699         stm_usb_bdt[AO_USB_CONTROL_EPR].single.count_tx = this_len;
700         ao_usb_set_stat_tx(AO_USB_CONTROL_EPR, STM_USB_EPR_STAT_TX_VALID);
701         debug ("queue tx. epr 0 now %08x\n", stm_usb.epr[AO_USB_CONTROL_EPR]);
702 }
703
704 /* Read data from the ep0 OUT fifo */
705 static void
706 ao_usb_ep0_fill(void)
707 {
708         uint16_t        len = stm_usb_bdt[0].single.count_rx & STM_USB_BDT_COUNT_RX_COUNT_RX_MASK;
709
710         if (len > ao_usb_ep0_out_len)
711                 len = ao_usb_ep0_out_len;
712         ao_usb_ep0_out_len -= (uint8_t) len;
713
714         /* Pull all of the data out of the packet */
715         debug_data ("Fill EP0 len %d:", len);
716         ao_usb_copy_rx(ao_usb_ep0_out_data, ao_usb_ep0_rx_offset, len);
717         debug_data ("\n");
718         ao_usb_ep0_out_data += len;
719
720         /* ACK the packet */
721         ao_usb_set_stat_rx(0, STM_USB_EPR_STAT_RX_VALID);
722 }
723
724 static void
725 ao_usb_ep0_in_reset(void)
726 {
727         ao_usb_ep0_in_data = ao_usb_ep0_in_buf;
728         ao_usb_ep0_in_len = 0;
729 }
730
731 static void
732 ao_usb_ep0_in_queue_byte(uint8_t a)
733 {
734         if (ao_usb_ep0_in_len < sizeof (ao_usb_ep0_in_buf))
735                 ao_usb_ep0_in_buf[ao_usb_ep0_in_len++] = a;
736 }
737
738 static void
739 ao_usb_ep0_in_set(const uint8_t *data, uint8_t len)
740 {
741         ao_usb_ep0_in_data = data;
742         ao_usb_ep0_in_len = len;
743 }
744
745 static void
746 ao_usb_ep0_out_set(uint8_t *data, uint8_t len)
747 {
748         ao_usb_ep0_out_data = data;
749         ao_usb_ep0_out_len = len;
750 }
751
752 static void
753 ao_usb_ep0_in_start(uint16_t max)
754 {
755         /* Don't send more than asked for */
756         if (ao_usb_ep0_in_len > max)
757                 ao_usb_ep0_in_len = (uint8_t) max;
758         ao_usb_ep0_flush();
759 }
760
761 struct ao_usb_line_coding ao_usb_line_coding = {115200, 0, 0, 8};
762
763 #if AO_USB_DEVICE_ID_SERIAL
764 static uint8_t ao_usb_serial[2 + 48];
765
766 /* Convert a 32-bit value to 8 hexidecimal UCS2 characters */
767 static void
768 hex_to_ucs2(uint32_t in, uint8_t *out)
769 {
770         int     i;
771
772         for (i = 28; i >= 0; i -= 4) {
773                 uint8_t bits = (in >> i) & 0xf;
774                 *out++ = (uint8_t) (((bits < 10) ? '0' : ('a' - 10)) + bits);
775                 *out++ = 0;
776         }
777 }
778
779 /* Encode the device ID (96 bits) in hexidecimal to use as a device
780  * serial number
781  */
782 static void
783 ao_usb_serial_init(void)
784 {
785         ao_usb_serial[0] = 50;  /* length */
786         ao_usb_serial[1] = AO_USB_DESC_STRING;
787         hex_to_ucs2(stm_device_id.u_id0, ao_usb_serial + 2 + 0);
788         hex_to_ucs2(stm_device_id.u_id1, ao_usb_serial + 2 + 16);
789         hex_to_ucs2(stm_device_id.u_id2, ao_usb_serial + 2 + 32);
790 }
791 #endif
792
793 /* Walk through the list of descriptors and find a match
794  */
795 static void
796 ao_usb_get_descriptor(uint16_t value, uint16_t length)
797 {
798         const uint8_t           *descriptor;
799         uint8_t         type = (uint8_t) (value >> 8);
800         uint8_t         index = (uint8_t) value;
801
802         descriptor = ao_usb_descriptors;
803         while (descriptor[0] != 0) {
804                 if (descriptor[1] == type && index-- == 0) {
805                         uint8_t len;
806                         if (type == AO_USB_DESC_CONFIGURATION)
807                                 len = descriptor[2];
808                         else
809                                 len = descriptor[0];
810 #if AO_USB_DEVICE_ID_SERIAL
811                         /* Slightly hacky - the serial number is string 3 */
812                         if (type == AO_USB_DESC_STRING && (value & 0xff) == 3) {
813                                 descriptor = ao_usb_serial;
814                                 len = sizeof (ao_usb_serial);
815                         }
816 #endif
817                         if (len > length)
818                                 len = (uint8_t) length;
819                         ao_usb_ep0_in_set(descriptor, len);
820                         break;
821                 }
822                 descriptor += descriptor[0];
823         }
824 }
825
826 static void
827 ao_usb_ep0_setup(void)
828 {
829         /* Pull the setup packet out of the fifo */
830         ao_usb_ep0_out_set((uint8_t *) &ao_usb_setup, 8);
831         ao_usb_ep0_fill();
832         if (ao_usb_ep0_out_len != 0) {
833                 debug ("invalid setup packet length\n");
834                 return;
835         }
836
837         if ((ao_usb_setup.dir_type_recip & AO_USB_DIR_IN) || ao_usb_setup.length == 0)
838                 ao_usb_ep0_state = AO_USB_EP0_DATA_IN;
839         else
840                 ao_usb_ep0_state = AO_USB_EP0_DATA_OUT;
841
842         ao_usb_ep0_in_reset();
843
844         switch(ao_usb_setup.dir_type_recip & AO_USB_SETUP_TYPE_MASK) {
845         case AO_USB_TYPE_STANDARD:
846                 debug ("Standard setup packet\n");
847                 switch(ao_usb_setup.dir_type_recip & AO_USB_SETUP_RECIP_MASK) {
848                 case AO_USB_RECIP_DEVICE:
849                         debug ("Device setup packet\n");
850                         switch(ao_usb_setup.request) {
851                         case AO_USB_REQ_GET_STATUS:
852                                 debug ("get status\n");
853                                 ao_usb_ep0_in_queue_byte(0);
854                                 ao_usb_ep0_in_queue_byte(0);
855                                 break;
856                         case AO_USB_REQ_SET_ADDRESS:
857                                 debug ("set address %d\n", ao_usb_setup.value);
858                                 ao_usb_address = (uint8_t) ao_usb_setup.value;
859                                 ao_usb_address_pending = 1;
860                                 break;
861                         case AO_USB_REQ_GET_DESCRIPTOR:
862                                 debug ("get descriptor %d\n", ao_usb_setup.value);
863                                 ao_usb_get_descriptor(ao_usb_setup.value, ao_usb_setup.length);
864                                 break;
865                         case AO_USB_REQ_GET_CONFIGURATION:
866                                 debug ("get configuration %d\n", ao_usb_configuration);
867                                 ao_usb_ep0_in_queue_byte(ao_usb_configuration);
868                                 break;
869                         case AO_USB_REQ_SET_CONFIGURATION:
870                                 ao_usb_configuration = (uint8_t) ao_usb_setup.value;
871                                 debug ("set configuration %d\n", ao_usb_configuration);
872                                 ao_usb_set_configuration();
873                                 break;
874                         }
875                         break;
876                 case AO_USB_RECIP_INTERFACE:
877                         debug ("Interface setup packet\n");
878                         switch(ao_usb_setup.request) {
879                         case AO_USB_REQ_GET_STATUS:
880                                 ao_usb_ep0_in_queue_byte(0);
881                                 ao_usb_ep0_in_queue_byte(0);
882                                 break;
883                         case AO_USB_REQ_GET_INTERFACE:
884                                 ao_usb_ep0_in_queue_byte(0);
885                                 break;
886                         case AO_USB_REQ_SET_INTERFACE:
887                                 break;
888                         }
889                         break;
890                 case AO_USB_RECIP_ENDPOINT:
891                         debug ("Endpoint setup packet\n");
892                         switch(ao_usb_setup.request) {
893                         case AO_USB_REQ_GET_STATUS:
894                                 ao_usb_ep0_in_queue_byte(0);
895                                 ao_usb_ep0_in_queue_byte(0);
896                                 break;
897                         }
898                         break;
899                 }
900                 break;
901         case AO_USB_TYPE_CLASS:
902                 debug ("Class setup packet\n");
903                 switch (ao_usb_setup.request) {
904                 case AO_USB_SET_LINE_CODING:
905                         debug ("set line coding\n");
906                         ao_usb_ep0_out_set((uint8_t *) &ao_usb_line_coding, 7);
907                         break;
908                 case AO_USB_GET_LINE_CODING:
909                         debug ("get line coding\n");
910                         ao_usb_ep0_in_set((const uint8_t *) &ao_usb_line_coding, 7);
911                         break;
912                 case AO_USB_SET_CONTROL_LINE_STATE:
913                         break;
914                 }
915                 break;
916         }
917
918         /* If we're not waiting to receive data from the host,
919          * queue an IN response
920          */
921         if (ao_usb_ep0_state == AO_USB_EP0_DATA_IN)
922                 ao_usb_ep0_in_start(ao_usb_setup.length);
923 }
924
925 static void
926 ao_usb_ep0_handle(uint8_t receive)
927 {
928         ao_usb_ep0_receive = 0;
929         if (receive & AO_USB_EP0_GOT_SETUP) {
930                 debug ("\tsetup\n");
931                 ao_usb_ep0_setup();
932         }
933         if (receive & AO_USB_EP0_GOT_RX_DATA) {
934                 debug ("\tgot rx data\n");
935                 if (ao_usb_ep0_state == AO_USB_EP0_DATA_OUT) {
936                         ao_usb_ep0_fill();
937                         if (ao_usb_ep0_out_len == 0) {
938                                 ao_usb_ep0_state = AO_USB_EP0_DATA_IN;
939                                 ao_usb_ep0_in_start(0);
940                         }
941                 }
942         }
943         if (receive & AO_USB_EP0_GOT_TX_ACK) {
944                 debug ("\tgot tx ack\n");
945
946 #if HAS_FLIGHT && AO_USB_FORCE_IDLE
947                 ao_flight_force_idle = 1;
948 #endif
949                 /* Wait until the IN packet is received from addr 0
950                  * before assigning our local address
951                  */
952                 if (ao_usb_address_pending)
953                         ao_usb_set_address(ao_usb_address);
954                 if (ao_usb_ep0_state == AO_USB_EP0_DATA_IN)
955                         ao_usb_ep0_flush();
956         }
957 }
958
959 #if AO_POWER_MANAGEMENT
960 static void
961 ao_usb_suspend(void)
962 {
963         stm_usb.cntr |= (1 << STM_USB_CNTR_FSUSP);
964         ao_power_suspend();
965         stm_usb.cntr |= (1 << STM_USB_CNTR_LP_MODE);
966         ao_clock_suspend();
967 }
968
969 static void
970 ao_usb_wakeup(void)
971 {
972         ao_clock_resume();
973         stm_usb.cntr &= (uint16_t) ~(1 << STM_USB_CNTR_FSUSP);
974         ao_power_resume();
975 }
976 #endif
977
978 void
979 stm_usb_isr(void)
980 {
981         uint32_t        istr = stm_usb.istr;
982
983         stm_usb.istr = (uint16_t) ~istr;
984         if (istr & (1 << STM_USB_ISTR_CTR)) {
985                 uint8_t         ep = istr & STM_USB_ISTR_EP_ID_MASK;
986                 uint16_t        epr, epr_write;
987
988                 /* Preserve the SW write bits, don't mess with most HW writable bits,
989                  * clear the CTR_RX and CTR_TX bits
990                  */
991                 epr = stm_usb.epr[ep].r;
992                 epr_write = epr;
993                 epr_write &= STM_USB_EPR_PRESERVE_MASK;
994                 epr_write |= STM_USB_EPR_INVARIANT;
995                 epr_write &= (uint16_t) ~(1 << STM_USB_EPR_CTR_RX);
996                 epr_write &= (uint16_t) ~(1 << STM_USB_EPR_CTR_TX);
997                 stm_usb.epr[ep].r = epr_write;
998
999                 switch (ep) {
1000                 case 0:
1001 #if USB_STATUS
1002                         ++control_count;
1003 #endif
1004                         if (ao_usb_epr_ctr_rx(epr)) {
1005                                 if (ao_usb_epr_setup(epr))
1006                                         ao_usb_ep0_receive |= AO_USB_EP0_GOT_SETUP;
1007                                 else
1008                                         ao_usb_ep0_receive |= AO_USB_EP0_GOT_RX_DATA;
1009                         }
1010                         if (ao_usb_epr_ctr_tx(epr))
1011                                 ao_usb_ep0_receive |= AO_USB_EP0_GOT_TX_ACK;
1012                         ao_usb_ep0_handle(ao_usb_ep0_receive);
1013                         break;
1014                 case AO_USB_OUT_EPR:
1015 #if USB_STATUS
1016                         ++out_count;
1017 #endif
1018                         if (ao_usb_epr_ctr_rx(epr)) {
1019                                 _rx_dbg1("RX ISR", epr);
1020                                 ao_usb_out_avail = 1;
1021                                 _rx_dbg0("out avail set");
1022                                 ao_wakeup(AO_USB_OUT_SLEEP_ADDR);
1023                                 _rx_dbg0("stdin awoken");
1024                         }
1025                         break;
1026                 case AO_USB_IN_EPR:
1027 #if USB_STATUS
1028                         ++in_count;
1029 #endif
1030                         _tx_dbg1("TX ISR", epr);
1031                         if (ao_usb_epr_ctr_tx(epr)) {
1032                                 ao_usb_in_pending = 0;
1033                                 ao_wakeup(&ao_usb_in_pending);
1034                         }
1035                         break;
1036 #if AO_USB_HAS_IN2
1037                 case AO_USB_IN2_EPR:
1038                         ++in2_count;
1039                         _tx_dbg1("TX2 ISR", epr);
1040                         if (ao_usb_epr_ctr_tx(epr)) {
1041                                 ao_usb_in2_pending = 0;
1042                                 ao_wakeup(&ao_usb_in2_pending);
1043                         }
1044                         break;
1045 #endif
1046 #if AO_USB_HAS_IN3
1047                 case AO_USB_IN3_EPR:
1048                         ++in3_count;
1049                         _tx_dbg1("TX3 ISR", epr);
1050                         if (ao_usb_epr_ctr_tx(epr)) {
1051                                 ao_usb_in3_pending = 0;
1052                                 ao_wakeup(&ao_usb_in3_pending);
1053                         }
1054                         break;
1055 #endif
1056                 case AO_USB_INT_EPR:
1057 #if USB_STATUS
1058                         ++int_count;
1059 #endif
1060                         if (ao_usb_epr_ctr_tx(epr))
1061                                 _ao_usb_set_stat_tx(AO_USB_INT_EPR, STM_USB_EPR_STAT_TX_NAK);
1062                         break;
1063                 }
1064                 return;
1065         }
1066
1067         if (istr & (1 << STM_USB_ISTR_RESET)) {
1068 #if USB_STATUS
1069                 ++reset_count;
1070 #endif
1071                 debug ("\treset\n");
1072                 ao_usb_set_ep0();
1073         }
1074 #if AO_POWER_MANAGEMENT
1075         if (istr & (1 << STM_USB_ISTR_SUSP)) {
1076                 debug ("\tsuspend\n");
1077                 ao_usb_suspend();
1078         }
1079         if (istr & (1 << STM_USB_ISTR_WKUP)) {
1080                 debug ("\twakeup\n");
1081                 ao_usb_wakeup();
1082         }
1083 #endif
1084 }
1085
1086 #if AO_USB_HAS_IN
1087 /* Queue the current IN buffer for transmission */
1088 static void
1089 _ao_usb_in_send(void)
1090 {
1091         _tx_dbg0("in_send start");
1092         debug ("send %d\n", ao_usb_tx_count);
1093         while (ao_usb_in_pending)
1094                 ao_sleep(&ao_usb_in_pending);
1095         ao_usb_in_pending = 1;
1096         if (ao_usb_tx_count != AO_USB_IN_SIZE)
1097                 ao_usb_in_flushed = 1;
1098         stm_usb_bdt[AO_USB_IN_EPR].double_tx[ao_usb_in_tx_which].count = ao_usb_tx_count;
1099         ao_usb_tx_count = 0;
1100
1101         /* Toggle our usage */
1102         ao_usb_in_tx_which = 1 - ao_usb_in_tx_which;
1103
1104         /* Toggle the SW_BUF flag */
1105         _ao_usb_toggle_dtog(AO_USB_IN_EPR, 1, 0);
1106
1107         /* Mark the outgoing buffer as valid */
1108         _ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID);
1109
1110         _tx_dbg0("in_send end");
1111 }
1112
1113 /* Wait for a free IN buffer. Interrupts are blocked */
1114 static void
1115 _ao_usb_in_wait(void)
1116 {
1117         for (;;) {
1118                 /* Check if the current buffer is writable */
1119                 if (ao_usb_tx_count < AO_USB_IN_SIZE)
1120                         break;
1121
1122                 _tx_dbg0("in_wait top");
1123                 /* Wait for an IN buffer to be ready */
1124                 while (ao_usb_in_pending)
1125                         ao_sleep(&ao_usb_in_pending);
1126                 _tx_dbg0("in_wait bottom");
1127         }
1128 }
1129
1130 void
1131 ao_usb_flush(void)
1132 {
1133         if (!ao_usb_running)
1134                 return;
1135
1136         /* Anytime we've sent a character since
1137          * the last time we flushed, we'll need
1138          * to send a packet -- the only other time
1139          * we would send a packet is when that
1140          * packet was full, in which case we now
1141          * want to send an empty packet
1142          */
1143         ao_arch_block_interrupts();
1144         while (!ao_usb_in_flushed) {
1145                 _tx_dbg0("flush top");
1146                 _ao_usb_in_send();
1147                 _tx_dbg0("flush end");
1148         }
1149         ao_arch_release_interrupts();
1150 }
1151
1152 void
1153 ao_usb_putchar(char c)
1154 {
1155         if (!ao_usb_running)
1156                 return;
1157
1158         ao_arch_block_interrupts();
1159         _ao_usb_in_wait();
1160
1161         ao_usb_in_flushed = 0;
1162         ao_usb_tx_byte((uint16_t) (ao_usb_in_tx_offset + AO_USB_IN_SIZE * ao_usb_in_tx_which + ao_usb_tx_count++), c);
1163
1164         /* Send the packet when full */
1165         if (ao_usb_tx_count == AO_USB_IN_SIZE) {
1166                 _tx_dbg0("putchar full");
1167                 _ao_usb_in_send();
1168                 _tx_dbg0("putchar flushed");
1169         }
1170         ao_arch_release_interrupts();
1171 }
1172 #endif
1173
1174 #if AO_USB_HAS_IN2
1175 /* Queue the current IN buffer for transmission */
1176 static void
1177 _ao_usb_in2_send(void)
1178 {
1179         _tx_dbg0("in2_send start");
1180         debug ("send2 %d\n", ao_usb_tx_count);
1181         while (ao_usb_in2_pending)
1182                 ao_sleep(&ao_usb_in2_pending);
1183         ao_usb_in2_pending = 1;
1184         if (ao_usb_tx2_count != AO_USB_IN_SIZE)
1185                 ao_usb_in2_flushed = 1;
1186         stm_usb_bdt[AO_USB_IN2_EPR].double_tx[ao_usb_in_tx2_which].count = ao_usb_tx2_count;
1187         ao_usb_tx2_count = 0;
1188
1189         /* Toggle our usage */
1190         ao_usb_in_tx2_which = 1 - ao_usb_in_tx2_which;
1191
1192         /* Toggle the SW_BUF flag */
1193         _ao_usb_toggle_dtog(AO_USB_IN2_EPR, 1, 0);
1194
1195         /* Mark the outgoing buffer as valid */
1196         _ao_usb_set_stat_tx(AO_USB_IN2_EPR, STM_USB_EPR_STAT_TX_VALID);
1197
1198         _tx_dbg0("in2_send end");
1199 }
1200
1201 /* Wait for a free IN buffer. Interrupts are blocked */
1202 static void
1203 _ao_usb_in2_wait(void)
1204 {
1205         for (;;) {
1206                 /* Check if the current buffer is writable */
1207                 if (ao_usb_tx2_count < AO_USB_IN_SIZE)
1208                         break;
1209
1210                 _tx_dbg0("in2_wait top");
1211                 /* Wait for an IN buffer to be ready */
1212                 while (ao_usb_in2_pending)
1213                         ao_sleep(&ao_usb_in2_pending);
1214                 _tx_dbg0("in_wait bottom");
1215         }
1216 }
1217
1218 void
1219 ao_usb_flush2(void)
1220 {
1221         if (!ao_usb_running)
1222                 return;
1223
1224         /* Anytime we've sent a character since
1225          * the last time we flushed, we'll need
1226          * to send a packet -- the only other time
1227          * we would send a packet is when that
1228          * packet was full, in which case we now
1229          * want to send an empty packet
1230          */
1231         ao_arch_block_interrupts();
1232         while (!ao_usb_in2_flushed) {
1233                 _tx_dbg0("flush2 top");
1234                 _ao_usb_in2_send();
1235                 _tx_dbg0("flush2 end");
1236         }
1237         ao_arch_release_interrupts();
1238 }
1239
1240 void
1241 ao_usb_putchar2(char c)
1242 {
1243         if (!ao_usb_running)
1244                 return;
1245
1246         ao_arch_block_interrupts();
1247         _ao_usb_in2_wait();
1248
1249         ao_usb_in2_flushed = 0;
1250         ao_usb_tx_byte((uint16_t) (ao_usb_in_tx2_offset + AO_USB_IN_SIZE * ao_usb_in_tx2_which + ao_usb_tx2_count++), c);
1251
1252         /* Send the packet when full */
1253         if (ao_usb_tx2_count == AO_USB_IN_SIZE) {
1254                 _tx_dbg0("putchar2 full");
1255                 _ao_usb_in2_send();
1256                 _tx_dbg0("putchar2 flushed");
1257         }
1258         ao_arch_release_interrupts();
1259 }
1260 #endif
1261
1262 #if AO_USB_HAS_IN3
1263 /* Queue the current IN buffer for transmission */
1264 static void
1265 _ao_usb_in3_send(void)
1266 {
1267         _tx_dbg0("in3_send start");
1268         debug ("send3 %d\n", ao_usb_tx3_count);
1269         while (ao_usb_in3_pending)
1270                 ao_sleep(&ao_usb_in3_pending);
1271         ao_usb_in3_pending = 1;
1272         if (ao_usb_tx3_count != AO_USB_IN_SIZE)
1273                 ao_usb_in3_flushed = 1;
1274         stm_usb_bdt[AO_USB_IN3_EPR].double_tx[ao_usb_in_tx3_which].count = ao_usb_tx3_count;
1275         ao_usb_tx3_count = 0;
1276
1277         /* Toggle our usage */
1278         ao_usb_in_tx3_which = 1 - ao_usb_in_tx3_which;
1279
1280         /* Toggle the SW_BUF flag */
1281         _ao_usb_toggle_dtog(AO_USB_IN3_EPR, 1, 0);
1282
1283         /* Mark the outgoing buffer as valid */
1284         _ao_usb_set_stat_tx(AO_USB_IN3_EPR, STM_USB_EPR_STAT_TX_VALID);
1285
1286         _tx_dbg0("in3_send end");
1287 }
1288
1289 /* Wait for a free IN buffer. Interrupts are blocked */
1290 static void
1291 _ao_usb_in3_wait(void)
1292 {
1293         for (;;) {
1294                 /* Check if the current buffer is writable */
1295                 if (ao_usb_tx3_count < AO_USB_IN_SIZE)
1296                         break;
1297
1298                 _tx_dbg0("in3_wait top");
1299                 /* Wait for an IN buffer to be ready */
1300                 while (ao_usb_in3_pending)
1301                         ao_sleep(&ao_usb_in3_pending);
1302                 _tx_dbg0("in_wait bottom");
1303         }
1304 }
1305
1306 void
1307 ao_usb_flush3(void)
1308 {
1309         if (!ao_usb_running)
1310                 return;
1311
1312         /* Anytime we've sent a character since
1313          * the last time we flushed, we'll need
1314          * to send a packet -- the only other time
1315          * we would send a packet is when that
1316          * packet was full, in which case we now
1317          * want to send an empty packet
1318          */
1319         ao_arch_block_interrupts();
1320         while (!ao_usb_in3_flushed) {
1321                 _tx_dbg0("flush3 top");
1322                 _ao_usb_in3_send();
1323                 _tx_dbg0("flush3 end");
1324         }
1325         ao_arch_release_interrupts();
1326 }
1327
1328 void
1329 ao_usb_putchar3(char c)
1330 {
1331         if (!ao_usb_running)
1332                 return;
1333
1334         ao_arch_block_interrupts();
1335         _ao_usb_in3_wait();
1336
1337         ao_usb_in3_flushed = 0;
1338         ao_usb_tx_byte((uint16_t) (ao_usb_in_tx3_offset + AO_USB_IN_SIZE * ao_usb_in_tx3_which + ao_usb_tx3_count++), c);
1339
1340         /* Send the packet when full */
1341         if (ao_usb_tx3_count == AO_USB_IN_SIZE) {
1342                 _tx_dbg0("putchar3 full");
1343                 _ao_usb_in3_send();
1344                 _tx_dbg0("putchar3 flushed");
1345         }
1346         ao_arch_release_interrupts();
1347 }
1348 #endif
1349
1350 #if AO_USB_HAS_OUT
1351 static void
1352 _ao_usb_out_recv(void)
1353 {
1354         _rx_dbg1("out_recv top", stm_usb.epr[AO_USB_OUT_EPR].r);
1355
1356         /* Clear packet available field until we get another interrupt */
1357         ao_usb_out_avail = 0;
1358
1359         /* Switch to new buffer */
1360         ao_usb_out_rx_which = 1 - ao_usb_out_rx_which;
1361
1362         ao_usb_rx_count = (uint8_t) (stm_usb_bdt[AO_USB_OUT_EPR].double_rx[ao_usb_out_rx_which].count & STM_USB_BDT_COUNT_RX_COUNT_RX_MASK);
1363         ao_usb_rx_pos = 0;
1364
1365         /* Toggle the SW_BUF_RX bit */
1366         _ao_usb_toggle_dtog(AO_USB_OUT_EPR, 0, 1);
1367
1368 //      /* Ack the packet */
1369 //      _ao_usb_set_stat_rx(AO_USB_OUT_EPR, STM_USB_EPR_STAT_RX_VALID);
1370
1371         _rx_dbg1("out_recv count", ao_usb_rx_count);
1372 }
1373
1374 static int
1375 _ao_usb_pollchar(void)
1376 {
1377         uint8_t c;
1378
1379         if (!ao_usb_running)
1380                 return AO_READ_AGAIN;
1381
1382         for (;;) {
1383                 if (ao_usb_rx_pos != ao_usb_rx_count)
1384                         break;
1385
1386 //              _rx_dbg0("poll check");
1387                 /* Check to see if a packet has arrived */
1388                 if (!ao_usb_out_avail) {
1389 //                      _rx_dbg0("poll none");
1390                         return AO_READ_AGAIN;
1391                 }
1392                 _ao_usb_out_recv();
1393         }
1394
1395         /* Pull a character out of the fifo */
1396         c = ao_usb_rx_byte((uint16_t) (ao_usb_out_rx_offset + ao_usb_out_rx_which * AO_USB_OUT_SIZE + ao_usb_rx_pos++));
1397         _rx_dbg1("char", c);
1398         return c;
1399 }
1400
1401 char
1402 ao_usb_getchar(void)
1403 {
1404         int     c;
1405
1406         ao_arch_block_interrupts();
1407         while ((c = _ao_usb_pollchar()) == AO_READ_AGAIN)
1408                 ao_sleep(AO_USB_OUT_SLEEP_ADDR);
1409         ao_arch_release_interrupts();
1410         return (char) c;
1411 }
1412 #endif
1413
1414 #if AO_USB_DIRECTIO
1415
1416 #if AO_USB_HAS_IN
1417 uint8_t
1418 ao_usb_alloc(uint16_t *buffers[2])
1419 {
1420         buffers[0] = ao_usb_packet_buffer_addr(ao_usb_in_tx_offset);
1421         buffers[1] = ao_usb_packet_buffer_addr(ao_usb_in_tx_offset + AO_USB_IN_SIZE);
1422         return ao_usb_in_tx_which;
1423 }
1424
1425 uint8_t
1426 ao_usb_write(uint16_t len)
1427 {
1428         ao_arch_block_interrupts();
1429
1430         /* Wait for everything to be ready at the same time */
1431         for (;;) {
1432                 /* Make sure USB is connected */
1433                 if (!ao_usb_running) {
1434                         ao_sleep(&ao_usb_running);
1435                         continue;
1436                 }
1437
1438                 /* Wait for an idle IN buffer */
1439                 if (ao_usb_in_pending) {
1440                         ao_sleep(&ao_usb_in_pending);
1441                         continue;
1442                 }
1443                 break;
1444         }
1445
1446         ao_usb_in_pending = 1;
1447         ao_usb_in_flushed = (len != AO_USB_IN_SIZE);
1448
1449         stm_usb_bdt[AO_USB_IN_EPR].double_tx[ao_usb_in_tx_which].count = len;
1450
1451         /* Toggle our usage */
1452         ao_usb_in_tx_which = 1 - ao_usb_in_tx_which;
1453
1454         /* Toggle the SW_BUF flag */
1455         _ao_usb_toggle_dtog(AO_USB_IN_EPR, 1, 0);
1456
1457         /* Mark the outgoing buffer as valid */
1458         _ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID);
1459
1460         ao_arch_release_interrupts();
1461         return ao_usb_in_tx_which;
1462 }
1463 #endif
1464
1465 #if AO_USB_HAS_IN2
1466
1467 uint8_t
1468 ao_usb_alloc2(uint16_t *buffers[2])
1469 {
1470         buffers[0] = ao_usb_packet_buffer_addr(ao_usb_in_tx2_offset);
1471         buffers[1] = ao_usb_packet_buffer_addr(ao_usb_in_tx2_offset + AO_USB_IN_SIZE);
1472         return ao_usb_in_tx2_which;
1473 }
1474
1475 uint8_t
1476 ao_usb_write2(uint16_t len)
1477 {
1478         ao_arch_block_interrupts();
1479
1480         /* Wait for everything to be ready at the same time */
1481         for (;;) {
1482                 /* Make sure USB is connected */
1483                 if (!ao_usb_running) {
1484                         ao_sleep(&ao_usb_running);
1485                         continue;
1486                 }
1487
1488                 /* Wait for an idle IN buffer */
1489                 if (ao_usb_in2_pending) {
1490                         ao_sleep(&ao_usb_in2_pending);
1491                         continue;
1492                 }
1493                 break;
1494         }
1495
1496         ao_usb_in2_pending = 1;
1497         ao_usb_in2_flushed = (len != AO_USB_IN_SIZE);
1498
1499         stm_usb_bdt[AO_USB_IN2_EPR].double_tx[ao_usb_in_tx2_which].count = len;
1500
1501         /* Toggle our usage */
1502         ao_usb_in_tx2_which = 1 - ao_usb_in_tx2_which;
1503
1504         /* Toggle the SW_BUF flag */
1505         _ao_usb_toggle_dtog(AO_USB_IN2_EPR, 1, 0);
1506
1507         /* Mark the outgoing buffer as valid */
1508         _ao_usb_set_stat_tx(AO_USB_IN2_EPR, STM_USB_EPR_STAT_TX_VALID);
1509         ao_arch_release_interrupts();
1510
1511         return ao_usb_in_tx2_which;
1512 }
1513 #endif
1514 #endif
1515
1516 void
1517 ao_usb_disable(void)
1518 {
1519         ao_arch_block_interrupts();
1520         stm_usb.cntr = (1 << STM_USB_CNTR_FRES);
1521         stm_usb.istr = 0;
1522
1523         /* Disable USB pull-up */
1524         stm_usb.bcdr &= (uint16_t) ~(1 << STM_USB_BCDR_DPPU);
1525
1526         /* Switch off the device */
1527         stm_usb.cntr = (1 << STM_USB_CNTR_PDWN) | (1 << STM_USB_CNTR_FRES);
1528
1529         /* Disable the interface */
1530         stm_rcc.apb1enr &= ~(1UL << STM_RCC_APB1ENR_USBEN);
1531         ao_arch_release_interrupts();
1532 }
1533
1534 void
1535 ao_usb_enable(void)
1536 {
1537         int     t;
1538
1539         /* Select HSI48 as USB clock source */
1540         stm_rcc.cfgr3 &= ~(1UL << STM_RCC_CFGR3_USBSW);
1541
1542         /* Enable USB device */
1543         stm_rcc.apb1enr |= (1 << STM_RCC_APB1ENR_USBEN);
1544
1545         /* Clear reset condition */
1546         stm_rcc.apb1rstr &= ~(1UL << STM_RCC_APB1RSTR_USBRST);
1547
1548         /* Disable USB pull-up */
1549         stm_usb.bcdr &= (uint16_t) ~(1 << STM_USB_BCDR_DPPU);
1550
1551         /* Do not touch the GPIOA configuration; USB takes priority
1552          * over GPIO on pins A11 and A12, but if you select alternate
1553          * input 10 (the documented correct selection), then USB is
1554          * pulled low and doesn't work at all
1555          */
1556
1557         ao_arch_block_interrupts();
1558
1559         /* Route interrupts */
1560         stm_nvic_set_enable(STM_ISR_USB_POS);
1561         stm_nvic_set_priority(STM_ISR_USB_POS, 3);
1562
1563         ao_usb_configuration = 0;
1564
1565         /* Set up buffer descriptors */
1566         ao_usb_init_btable();
1567
1568         /* Reset the USB controller */
1569         stm_usb.cntr = (1 << STM_USB_CNTR_FRES);
1570
1571         /* Clear the reset bit */
1572         stm_usb.cntr = 0;
1573
1574         /* Clear any spurious interrupts */
1575         stm_usb.istr = 0;
1576
1577         ao_usb_set_ep0();
1578
1579         debug ("ao_usb_enable\n");
1580
1581         /* Enable interrupts */
1582         stm_usb.cntr = ((1 << STM_USB_CNTR_CTRM) |
1583                         (0 << STM_USB_CNTR_PMAOVRM) |
1584                         (0 << STM_USB_CNTR_ERRM) |
1585                         (AO_POWER_MANAGEMENT << STM_USB_CNTR_WKUPM) |
1586                         (AO_POWER_MANAGEMENT << STM_USB_CNTR_SUSPM) |
1587                         (1 << STM_USB_CNTR_RESETM) |
1588                         (0 << STM_USB_CNTR_SOFM) |
1589                         (0 << STM_USB_CNTR_ESOFM) |
1590                         (0 << STM_USB_CNTR_RESUME) |
1591                         (0 << STM_USB_CNTR_FSUSP) |
1592                         (0 << STM_USB_CNTR_LP_MODE) |
1593                         (0 << STM_USB_CNTR_PDWN) |
1594                         (0 << STM_USB_CNTR_FRES));
1595
1596         ao_arch_release_interrupts();
1597
1598         for (t = 0; t < 50000; t++)
1599                 ao_arch_nop();
1600
1601         /* Enable USB pull-up */
1602         stm_usb.bcdr |= (1 << STM_USB_BCDR_DPPU);
1603 }
1604
1605 #if USB_ECHO
1606 struct ao_task ao_usb_echo_task;
1607
1608 static void
1609 ao_usb_echo(void)
1610 {
1611         char    c;
1612
1613         for (;;) {
1614                 c = ao_usb_getchar();
1615                 ao_usb_putchar(c);
1616                 ao_usb_flush();
1617         }
1618 }
1619 #endif
1620
1621 #if USB_STATUS
1622 static void
1623 ao_usb_irq(void)
1624 {
1625         printf ("control: %d out: %d in: %d int: %d reset: %d\n",
1626                 control_count, out_count, in_count, int_count, reset_count);
1627 }
1628
1629 const struct ao_cmds ao_usb_cmds[] = {
1630         { ao_usb_irq, "I\0Show USB interrupt counts" },
1631         { 0, NULL }
1632 };
1633 #endif
1634
1635 void
1636 ao_usb_init(void)
1637 {
1638         /* Turn on syscfg */
1639         stm_rcc.apb2enr |= (1 << STM_RCC_APB2ENR_SYSCFGCOMPEN);
1640
1641         /* Set PA11/PA12 remapping bit */
1642         stm_syscfg.cfgr1 |= (AO_PA11_PA12_RMP << STM_SYSCFG_CFGR1_PA11_PA12_RMP);
1643
1644 #ifndef AO_USB_START_DISABLED
1645         ao_usb_enable();
1646 #endif
1647
1648 #if AO_USB_DEVICE_ID_SERIAL
1649         ao_usb_serial_init();
1650 #endif
1651
1652         debug ("ao_usb_init\n");
1653         ao_usb_ep0_state = AO_USB_EP0_IDLE;
1654
1655         ao_usb_alloc_buffers();
1656
1657 #if USB_ECHO
1658         ao_add_task(&ao_usb_echo_task, ao_usb_echo, "usb echo");
1659 #endif
1660 #if USB_STATUS
1661         ao_cmd_register(&ao_usb_cmds[0]);
1662 #endif
1663 #if !USB_ECHO
1664 #if USE_USB_STDIO
1665         ao_add_stdio(_ao_usb_pollchar, ao_usb_putchar, ao_usb_flush);
1666 #endif
1667 #endif
1668 }
1669
1670 #if TX_DBG || RX_DBG
1671
1672 struct ao_usb_dbg {
1673         int             line;
1674         char            *msg;
1675         uint32_t        value;
1676         uint32_t        primask;
1677 #if TX_DBG
1678         uint16_t        in_count;
1679         uint32_t        in_epr;
1680         uint32_t        in_pending;
1681         uint32_t        tx_count;
1682         uint32_t        in_flushed;
1683 #endif
1684 #if RX_DBG
1685         uint8_t         rx_count;
1686         uint8_t         rx_pos;
1687         uint8_t         out_avail;
1688         uint32_t        out_epr;
1689 #endif
1690 };
1691
1692 #define NUM_USB_DBG     16
1693
1694 struct ao_usb_dbg dbg[NUM_USB_DBG];
1695 int dbg_i;
1696
1697 static void _dbg(int line, char *msg, uint32_t value)
1698 {
1699         uint32_t        primask;
1700         dbg[dbg_i].line = line;
1701         dbg[dbg_i].msg = msg;
1702         dbg[dbg_i].value = value;
1703         asm("mrs %0,primask" : "=&r" (primask));
1704         dbg[dbg_i].primask = primask;
1705 #if TX_DBG
1706         dbg[dbg_i].in_count = in3_count;
1707         dbg[dbg_i].in_epr = stm_usb.epr[AO_USB_IN3_EPR].r;
1708         dbg[dbg_i].in_pending = ao_usb_in3_pending;
1709         dbg[dbg_i].tx_count = ao_usb_tx3_count;
1710         dbg[dbg_i].in_flushed = ao_usb_in3_flushed;
1711 #endif
1712 #if RX_DBG
1713         dbg[dbg_i].rx_count = ao_usb_rx_count;
1714         dbg[dbg_i].rx_pos = ao_usb_rx_pos;
1715         dbg[dbg_i].out_avail = ao_usb_out_avail;
1716         dbg[dbg_i].out_epr = stm_usb.epr[AO_USB_OUT_EPR].r;
1717 #endif
1718         if (++dbg_i == NUM_USB_DBG)
1719                 dbg_i = 0;
1720 }
1721 #endif