557afff55121f4e9bccfaf0820ab231ce808980c
[openocd.git] / src / jtag / drivers / OpenULINK / src / usb.c
1 /***************************************************************************
2 * Copyright (C) 2011 by Martin Schmoelzer *
3 * <martin.schmoelzer@student.tuwien.ac.at> *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
20
21 /**
22 * @file
23 * Defines USB descriptors, interrupt routines and helper functions.
24 * To minimize code size, we make the following assumptions:
25 * - The OpenULINK has exactly one configuration
26 * - and exactly one alternate setting
27 *
28 * Therefore, we do not have to support the Set Configuration USB request.
29 */
30
31 #include "usb.h"
32 #include "delay.h"
33 #include "io.h"
34
35 /* Also update external declarations in "include/usb.h" if making changes to
36 * these variables! */
37 volatile bool EP2_out;
38 volatile bool EP2_in;
39
40 volatile __xdata __at 0x7FE8 struct setup_data setup_data;
41
42 /* Define number of endpoints (except Control Endpoint 0) in a central place.
43 * Be sure to include the neccessary endpoint descriptors! */
44 #define NUM_ENDPOINTS 2
45
46 /*
47 * Normally, we would initialize the descriptor structures in C99 style:
48 *
49 * __code usb_device_descriptor_t device_descriptor = {
50 * .bLength = foo,
51 * .bDescriptorType = bar,
52 * .bcdUSB = 0xABCD,
53 * ...
54 * };
55 *
56 * But SDCC currently does not support this, so we have to do it the
57 * old-fashioned way...
58 */
59
60 __code struct usb_device_descriptor device_descriptor = {
61 /* .bLength = */ sizeof(struct usb_device_descriptor),
62 /* .bDescriptorType = */ DESCRIPTOR_TYPE_DEVICE,
63 /* .bcdUSB = */ 0x0110, /* BCD: 01.00 (Version 1.0 USB spec) */
64 /* .bDeviceClass = */ 0xFF, /* 0xFF = vendor-specific */
65 /* .bDeviceSubClass = */ 0xFF,
66 /* .bDeviceProtocol = */ 0xFF,
67 /* .bMaxPacketSize0 = */ 64,
68 /* .idVendor = */ 0xC251,
69 /* .idProduct = */ 0x2710,
70 /* .bcdDevice = */ 0x0100,
71 /* .iManufacturer = */ 1,
72 /* .iProduct = */ 2,
73 /* .iSerialNumber = */ 3,
74 /* .bNumConfigurations = */ 1
75 };
76
77 /* WARNING: ALL config, interface and endpoint descriptors MUST be adjacent! */
78
79 __code struct usb_config_descriptor config_descriptor = {
80 /* .bLength = */ sizeof(struct usb_config_descriptor),
81 /* .bDescriptorType = */ DESCRIPTOR_TYPE_CONFIGURATION,
82 /* .wTotalLength = */ sizeof(struct usb_config_descriptor) +
83 sizeof(struct usb_interface_descriptor) +
84 (NUM_ENDPOINTS *
85 sizeof(struct usb_endpoint_descriptor)),
86 /* .bNumInterfaces = */ 1,
87 /* .bConfigurationValue = */ 1,
88 /* .iConfiguration = */ 4, /* String describing this configuration */
89 /* .bmAttributes = */ 0x80, /* Only MSB set according to USB spec */
90 /* .MaxPower = */ 50 /* 100 mA */
91 };
92
93 __code struct usb_interface_descriptor interface_descriptor00 = {
94 /* .bLength = */ sizeof(struct usb_interface_descriptor),
95 /* .bDescriptorType = */ DESCRIPTOR_TYPE_INTERFACE,
96 /* .bInterfaceNumber = */ 0,
97 /* .bAlternateSetting = */ 0,
98 /* .bNumEndpoints = */ NUM_ENDPOINTS,
99 /* .bInterfaceClass = */ 0xFF,
100 /* .bInterfaceSubclass = */ 0xFF,
101 /* .bInterfaceProtocol = */ 0xFF,
102 /* .iInterface = */ 0
103 };
104
105 __code struct usb_endpoint_descriptor Bulk_EP2_IN_Endpoint_Descriptor = {
106 /* .bLength = */ sizeof(struct usb_endpoint_descriptor),
107 /* .bDescriptorType = */ 0x05,
108 /* .bEndpointAddress = */ 2 | USB_DIR_IN,
109 /* .bmAttributes = */ 0x02,
110 /* .wMaxPacketSize = */ 64,
111 /* .bInterval = */ 0
112 };
113
114 __code struct usb_endpoint_descriptor Bulk_EP2_OUT_Endpoint_Descriptor = {
115 /* .bLength = */ sizeof(struct usb_endpoint_descriptor),
116 /* .bDescriptorType = */ 0x05,
117 /* .bEndpointAddress = */ 2 | USB_DIR_OUT,
118 /* .bmAttributes = */ 0x02,
119 /* .wMaxPacketSize = */ 64,
120 /* .bInterval = */ 0
121 };
122
123 __code struct usb_language_descriptor language_descriptor = {
124 /* .bLength = */ 4,
125 /* .bDescriptorType = */ DESCRIPTOR_TYPE_STRING,
126 /* .wLANGID = */ {0x0409 /* US English */}
127 };
128
129 __code struct usb_string_descriptor strManufacturer =
130 STR_DESCR(9, 'O', 'p', 'e', 'n', 'U', 'L', 'I', 'N', 'K');
131
132 __code struct usb_string_descriptor strProduct =
133 STR_DESCR(9, 'O', 'p', 'e', 'n', 'U', 'L', 'I', 'N', 'K');
134
135 __code struct usb_string_descriptor strSerialNumber =
136 STR_DESCR(6, '0', '0', '0', '0', '0', '1');
137
138 __code struct usb_string_descriptor strConfigDescr =
139 STR_DESCR(12, 'J', 'T', 'A', 'G', ' ', 'A', 'd', 'a', 'p', 't', 'e', 'r');
140
141 /* Table containing pointers to string descriptors */
142 __code struct usb_string_descriptor *__code en_string_descriptors[4] = {
143 &strManufacturer,
144 &strProduct,
145 &strSerialNumber,
146 &strConfigDescr
147 };
148
149 void sudav_isr(void) __interrupt SUDAV_ISR
150 {
151 CLEAR_IRQ();
152
153 usb_handle_setup_data();
154
155 USBIRQ = SUDAVIR;
156 EP0CS |= HSNAK;
157 }
158
159 void sof_isr(void) __interrupt SOF_ISR
160 {
161 }
162 void sutok_isr(void) __interrupt SUTOK_ISR
163 {
164 }
165 void suspend_isr(void) __interrupt SUSPEND_ISR
166 {
167 }
168 void usbreset_isr(void) __interrupt USBRESET_ISR
169 {
170 }
171 void ibn_isr(void) __interrupt IBN_ISR
172 {
173 }
174
175 void ep0in_isr(void) __interrupt EP0IN_ISR
176 {
177 }
178 void ep0out_isr(void) __interrupt EP0OUT_ISR
179 {
180 }
181 void ep1in_isr(void) __interrupt EP1IN_ISR
182 {
183 }
184 void ep1out_isr(void) __interrupt EP1OUT_ISR
185 {
186 }
187
188 /**
189 * EP2 IN: called after the transfer from uC->Host has finished: we sent data
190 */
191 void ep2in_isr(void) __interrupt EP2IN_ISR
192 {
193 EP2_in = 1;
194
195 CLEAR_IRQ();
196 IN07IRQ = IN2IR;/* Clear OUT2 IRQ */
197 }
198
199 /**
200 * EP2 OUT: called after the transfer from Host->uC has finished: we got data
201 */
202 void ep2out_isr(void) __interrupt EP2OUT_ISR
203 {
204 EP2_out = 1;
205
206 CLEAR_IRQ();
207 OUT07IRQ = OUT2IR; /* Clear OUT2 IRQ */
208 }
209
210 void ep3in_isr(void) __interrupt EP3IN_ISR
211 {
212 }
213 void ep3out_isr(void) __interrupt EP3OUT_ISR
214 {
215 }
216 void ep4in_isr(void) __interrupt EP4IN_ISR
217 {
218 }
219 void ep4out_isr(void) __interrupt EP4OUT_ISR
220 {
221 }
222 void ep5in_isr(void) __interrupt EP5IN_ISR
223 {
224 }
225 void ep5out_isr(void) __interrupt EP5OUT_ISR
226 {
227 }
228 void ep6in_isr(void) __interrupt EP6IN_ISR
229 {
230 }
231 void ep6out_isr(void) __interrupt EP6OUT_ISR
232 {
233 }
234 void ep7in_isr(void) __interrupt EP7IN_ISR
235 {
236 }
237 void ep7out_isr(void) __interrupt EP7OUT_ISR
238 {
239 }
240
241 /**
242 * Return the control/status register for an endpoint
243 *
244 * @param ep endpoint address
245 * @return on success: pointer to Control & Status register for endpoint
246 * specified in \a ep
247 * @return on failure: NULL
248 */
249 __xdata uint8_t *usb_get_endpoint_cs_reg(uint8_t ep)
250 {
251 /* Mask direction bit */
252 uint8_t ep_num = ep & 0x7F;
253
254 switch (ep_num) {
255 case 0:
256 return &EP0CS;
257 break;
258 case 1:
259 return ep & 0x80 ? &IN1CS : &OUT1CS;
260 break;
261 case 2:
262 return ep & 0x80 ? &IN2CS : &OUT2CS;
263 break;
264 case 3:
265 return ep & 0x80 ? &IN3CS : &OUT3CS;
266 break;
267 case 4:
268 return ep & 0x80 ? &IN4CS : &OUT4CS;
269 break;
270 case 5:
271 return ep & 0x80 ? &IN5CS : &OUT5CS;
272 break;
273 case 6:
274 return ep & 0x80 ? &IN6CS : &OUT6CS;
275 break;
276 case 7:
277 return ep & 0x80 ? &IN7CS : &OUT7CS;
278 break;
279 }
280
281 return NULL;
282 }
283
284 void usb_reset_data_toggle(uint8_t ep)
285 {
286 /* TOGCTL register:
287 +----+-----+-----+------+-----+-------+-------+-------+
288 | Q | S | R | IO | 0 | EP2 | EP1 | EP0 |
289 +----+-----+-----+------+-----+-------+-------+-------+
290
291 To reset data toggle bits, we have to write the endpoint direction (IN/OUT)
292 to the IO bit and the endpoint number to the EP2..EP0 bits. Then, in a
293 separate write cycle, the R bit needs to be set.
294 */
295 uint8_t togctl_value = (ep & 0x80 >> 3) | (ep & 0x7);
296
297 /* First step: Write EP number and direction bit */
298 TOGCTL = togctl_value;
299
300 /* Second step: Set R bit */
301 togctl_value |= TOG_R;
302 TOGCTL = togctl_value;
303 }
304
305 /**
306 * Handle GET_STATUS request.
307 *
308 * @return on success: true
309 * @return on failure: false
310 */
311 bool usb_handle_get_status(void)
312 {
313 uint8_t *ep_cs;
314
315 switch (setup_data.bmRequestType) {
316 case GS_DEVICE:
317 /* Two byte response: Byte 0, Bit 0 = self-powered, Bit 1 = remote wakeup.
318 * Byte 1: reserved, reset to zero */
319 IN0BUF[0] = 0;
320 IN0BUF[1] = 0;
321
322 /* Send response */
323 IN0BC = 2;
324 break;
325 case GS_INTERFACE:
326 /* Always return two zero bytes according to USB 1.1 spec, p. 191 */
327 IN0BUF[0] = 0;
328 IN0BUF[1] = 0;
329
330 /* Send response */
331 IN0BC = 2;
332 break;
333 case GS_ENDPOINT:
334 /* Get stall bit for endpoint specified in low byte of wIndex */
335 ep_cs = usb_get_endpoint_cs_reg(setup_data.wIndex & 0xff);
336
337 if (*ep_cs & EPSTALL)
338 IN0BUF[0] = 0x01;
339 else
340 IN0BUF[0] = 0x00;
341
342 /* Second byte sent has to be always zero */
343 IN0BUF[1] = 0;
344
345 /* Send response */
346 IN0BC = 2;
347 break;
348 default:
349 return false;
350 break;
351 }
352
353 return true;
354 }
355
356 /**
357 * Handle CLEAR_FEATURE request.
358 *
359 * @return on success: true
360 * @return on failure: false
361 */
362 bool usb_handle_clear_feature(void)
363 {
364 __xdata uint8_t *ep_cs;
365
366 switch (setup_data.bmRequestType) {
367 case CF_DEVICE:
368 /* Clear remote wakeup not supported: stall EP0 */
369 STALL_EP0();
370 break;
371 case CF_ENDPOINT:
372 if (setup_data.wValue == 0) {
373 /* Unstall the endpoint specified in wIndex */
374 ep_cs = usb_get_endpoint_cs_reg(setup_data.wIndex);
375 if (!ep_cs)
376 return false;
377 *ep_cs &= ~EPSTALL;
378 } else {
379 /* Unsupported feature, stall EP0 */
380 STALL_EP0();
381 }
382 break;
383 default:
384 /* Vendor commands... */
385 }
386
387 return true;
388 }
389
390 /**
391 * Handle SET_FEATURE request.
392 *
393 * @return on success: true
394 * @return on failure: false
395 */
396 bool usb_handle_set_feature(void)
397 {
398 __xdata uint8_t *ep_cs;
399
400 switch (setup_data.bmRequestType) {
401 case SF_DEVICE:
402 if (setup_data.wValue == 2)
403 return true;
404 break;
405 case SF_ENDPOINT:
406 if (setup_data.wValue == 0) {
407 /* Stall the endpoint specified in wIndex */
408 ep_cs = usb_get_endpoint_cs_reg(setup_data.wIndex);
409 if (!ep_cs)
410 return false;
411 *ep_cs |= EPSTALL;
412 } else {
413 /* Unsupported endpoint feature */
414 return false;
415 }
416 break;
417 default:
418 /* Vendor commands... */
419 break;
420 }
421
422 return true;
423 }
424
425 /**
426 * Handle GET_DESCRIPTOR request.
427 *
428 * @return on success: true
429 * @return on failure: false
430 */
431 bool usb_handle_get_descriptor(void)
432 {
433 __xdata uint8_t descriptor_type;
434 __xdata uint8_t descriptor_index;
435
436 descriptor_type = (setup_data.wValue & 0xff00) >> 8;
437 descriptor_index = setup_data.wValue & 0x00ff;
438
439 switch (descriptor_type) {
440 case DESCRIPTOR_TYPE_DEVICE:
441 SUDPTRH = HI8(&device_descriptor);
442 SUDPTRL = LO8(&device_descriptor);
443 break;
444 case DESCRIPTOR_TYPE_CONFIGURATION:
445 SUDPTRH = HI8(&config_descriptor);
446 SUDPTRL = LO8(&config_descriptor);
447 break;
448 case DESCRIPTOR_TYPE_STRING:
449 if (setup_data.wIndex == 0) {
450 /* Supply language descriptor */
451 SUDPTRH = HI8(&language_descriptor);
452 SUDPTRL = LO8(&language_descriptor);
453 } else if (setup_data.wIndex == 0x0409 /* US English */) {
454 /* Supply string descriptor */
455 SUDPTRH = HI8(en_string_descriptors[descriptor_index - 1]);
456 SUDPTRL = LO8(en_string_descriptors[descriptor_index - 1]);
457 } else
458 return false;
459 break;
460 default:
461 /* Unsupported descriptor type */
462 return false;
463 break;
464 }
465
466 return true;
467 }
468
469 /**
470 * Handle SET_INTERFACE request.
471 */
472 void usb_handle_set_interface(void)
473 {
474 /* Reset Data Toggle */
475 usb_reset_data_toggle(USB_DIR_IN | 2);
476 usb_reset_data_toggle(USB_DIR_OUT | 2);
477
478 /* Unstall & clear busy flag of all valid IN endpoints */
479 IN2CS = 0 | EPBSY;
480
481 /* Unstall all valid OUT endpoints, reset bytecounts */
482 OUT2CS = 0;
483 OUT2BC = 0;
484 }
485
486 /**
487 * Handle the arrival of a USB Control Setup Packet.
488 */
489 void usb_handle_setup_data(void)
490 {
491 switch (setup_data.bRequest) {
492 case GET_STATUS:
493 if (!usb_handle_get_status())
494 STALL_EP0();
495 break;
496 case CLEAR_FEATURE:
497 if (!usb_handle_clear_feature())
498 STALL_EP0();
499 break;
500 case 2: case 4:
501 /* Reserved values */
502 STALL_EP0();
503 break;
504 case SET_FEATURE:
505 if (!usb_handle_set_feature())
506 STALL_EP0();
507 break;
508 case SET_ADDRESS:
509 /* Handled by USB core */
510 break;
511 case SET_DESCRIPTOR:
512 /* Set Descriptor not supported. */
513 STALL_EP0();
514 break;
515 case GET_DESCRIPTOR:
516 if (!usb_handle_get_descriptor())
517 STALL_EP0();
518 break;
519 case GET_CONFIGURATION:
520 /* OpenULINK has only one configuration, return its index */
521 IN0BUF[0] = config_descriptor.bConfigurationValue;
522 IN0BC = 1;
523 break;
524 case SET_CONFIGURATION:
525 /* OpenULINK has only one configuration -> nothing to do */
526 break;
527 case GET_INTERFACE:
528 /* OpenULINK only has one interface, return its number */
529 IN0BUF[0] = interface_descriptor00.bInterfaceNumber;
530 IN0BC = 1;
531 break;
532 case SET_INTERFACE:
533 usb_handle_set_interface();
534 break;
535 case SYNCH_FRAME:
536 /* Isochronous endpoints not used -> nothing to do */
537 break;
538 default:
539 /* Any other requests: do nothing */
540 break;
541 }
542 }
543
544 /**
545 * USB initialization. Configures USB interrupts, endpoints and performs
546 * ReNumeration.
547 */
548 void usb_init(void)
549 {
550 /* Mark endpoint 2 IN & OUT as valid */
551 IN07VAL = IN2VAL;
552 OUT07VAL = OUT2VAL;
553
554 /* Make sure no isochronous endpoints are marked valid */
555 INISOVAL = 0;
556 OUTISOVAL = 0;
557
558 /* Disable isochronous endpoints. This makes the isochronous data buffers
559 * available as 8051 XDATA memory at address 0x2000 - 0x27FF */
560 ISOCTL = ISODISAB;
561
562 /* Enable USB Autovectoring */
563 USBBAV |= AVEN;
564
565 /* Enable SUDAV interrupt */
566 USBIEN |= SUDAVIE;
567
568 /* Enable EP2 OUT & IN interrupts */
569 OUT07IEN = OUT2IEN;
570 IN07IEN = IN2IEN;
571
572 /* Enable USB interrupt (EIE register) */
573 EUSB = 1;
574
575 /* Perform ReNumeration */
576 USBCS = DISCON | RENUM;
577 delay_ms(200);
578 USBCS = DISCOE | RENUM;
579 }