178715646a27be382c08da6d49232556d878286f
[gnuk/gnuk.git] / src / usb_prop.c
1 /*
2  * usb_prop.c - interface code between Gnuk and USB
3  *
4  * Copyright (C) 2010, 2011, 2012 Free Software Initiative of Japan
5  * Author: NIIBE Yutaka <gniibe@fsij.org>
6  *
7  * This file is a part of Gnuk, a GnuPG USB Token implementation.
8  *
9  * Gnuk is free software: you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17  * License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 /* Packet size of USB Bulk transfer for full speed */
25 #define GNUK_MAX_PACKET_SIZE 64
26
27 #include "config.h"
28 #include "ch.h"
29 #include "usb_lld.h"
30 #include "usb_conf.h"
31
32 #ifdef ENABLE_VIRTUAL_COM_PORT
33 #include "usb-cdc.h"
34
35 struct line_coding
36 {
37   uint32_t bitrate;
38   uint8_t format;
39   uint8_t paritytype;
40   uint8_t datatype;
41 };
42
43 static const struct line_coding line_coding = {
44   115200, /* baud rate: 115200    */
45   0x00,   /* stop bits: 1         */
46   0x00,   /* parity:    none      */
47   0x08    /* bits:      8         */
48 };
49
50 static void
51 vcom_port_data_setup (uint8_t RequestNo)
52 {
53   if (RequestNo != USB_CDC_REQ_GET_LINE_CODING)
54     return;
55
56   /* RequestNo == USB_CDC_REQ_SET_LINE_CODING is not supported */
57
58   usb_lld_set_data_to_send (&line_coding, sizeof(line_coding));
59 }
60
61 static int
62 vcom_port_setup_with_nodata (uint8_t RequestNo)
63 {
64   if (RequestNo == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
65     /* Do nothing and success  */
66     return USB_SUCCESS;
67
68   return USB_UNSUPPORT;
69 }
70
71 #define VCOM_NUM_INTERFACES 2
72 #else
73 #define VCOM_NUM_INTERFACES 0
74 #endif
75
76 #ifdef PINPAD_DND_SUPPORT
77 #include "usb-msc.h"
78 #define MSC_NUM_INTERFACES 1
79 #else
80 #define MSC_NUM_INTERFACES 0
81 #endif
82
83 #define NUM_INTERFACES (1+VCOM_NUM_INTERFACES+MSC_NUM_INTERFACES)
84 #define MSC_INTERFACE_NO (1+VCOM_NUM_INTERFACES)
85
86 uint32_t bDeviceState = UNCONNECTED; /* USB device status */
87
88 static void
89 gnuk_device_init (void)
90 {
91   usb_lld_set_configuration (0);
92   USB_Cable_Config (1);
93   bDeviceState = UNCONNECTED;
94 }
95
96 static void
97 gnuk_setup_endpoints_for_interface (uint16_t interface, int stop)
98 {
99   if (interface == 0)
100     {
101       if (!stop)
102         usb_lld_setup_endpoint (ENDP1, EP_BULK, 0, ENDP1_RXADDR, ENDP1_TXADDR,
103                                 GNUK_MAX_PACKET_SIZE);
104       else
105         {
106           usb_lld_stall_rx (ENDP1);
107           usb_lld_stall_tx (ENDP1);
108         }
109     }
110 #ifdef ENABLE_VIRTUAL_COM_PORT
111   else if (interface == 1)
112     {
113       if (!stop)
114         usb_lld_setup_endpoint (ENDP4, EP_INTERRUPT, 0, 0, ENDP4_TXADDR, 0);
115       else
116         usb_lld_stall_tx (ENDP4);
117     }
118   else if (interface == 2)
119     {
120       if (!stop)
121         {
122           usb_lld_setup_endpoint (ENDP3, EP_BULK, 0, 0, ENDP3_TXADDR, 0);
123           usb_lld_setup_endpoint (ENDP5, EP_BULK, 0, ENDP5_RXADDR, 0,
124                                   VIRTUAL_COM_PORT_DATA_SIZE);
125         }
126       else
127         {
128           usb_lld_stall_tx (ENDP3);
129           usb_lld_stall_rx (ENDP5);
130         }
131     }
132 #endif
133 #ifdef PINPAD_DND_SUPPORT
134   else if (interface == MSC_INTERFACE_NO)
135     {
136       if (!stop)
137         {
138           usb_lld_setup_endpoint (ENDP6, EP_BULK, 0,
139                                   ENDP6_RXADDR, ENDP6_TXADDR, 64);
140           usb_lld_stall_rx (ENDP6);
141         }
142       else
143         {
144           usb_lld_stall_tx (ENDP6);
145           usb_lld_stall_rx (ENDP6);
146         }
147     }
148 #endif
149 }
150
151 static void
152 gnuk_device_reset (void)
153 {
154   int i;
155
156   /* Set DEVICE as not configured */
157   usb_lld_set_configuration (0);
158
159   /* Current Feature initialization */
160   usb_lld_set_feature (Config_Descriptor.Descriptor[7]);
161
162   usb_lld_reset ();
163
164   /* Initialize Endpoint 0 */
165   usb_lld_setup_endpoint (ENDP0, EP_CONTROL, 0, ENDP0_RXADDR, ENDP0_TXADDR,
166                           GNUK_MAX_PACKET_SIZE);
167
168   for (i = 0; i < NUM_INTERFACES; i++)
169     gnuk_setup_endpoints_for_interface (i, 0);
170
171   bDeviceState = ATTACHED;
172 }
173
174 #define USB_CCID_REQ_ABORT                      0x01
175 #define USB_CCID_REQ_GET_CLOCK_FREQUENCIES      0x02
176 #define USB_CCID_REQ_GET_DATA_RATES             0x03
177
178 static const uint8_t freq_table[] = { 0xf3, 0x0d, 0, 0, }; /* dwDefaultClock */
179
180 static const uint8_t data_rate_table[] = { 0x80, 0x25, 0, 0, }; /* dwDataRate */
181
182 #if defined(PINPAD_DND_SUPPORT)
183 static const uint8_t lun_table[] = { 0, 0, 0, 0, };
184 #endif
185
186 static void
187 gnuk_setup_with_data (uint8_t recipient, uint8_t RequestNo, uint16_t index)
188 {
189   if (recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT)) /* Interface */
190     {
191       if (index == 0)
192         {
193           if (RequestNo == USB_CCID_REQ_GET_CLOCK_FREQUENCIES)
194             usb_lld_set_data_to_send (freq_table, sizeof (freq_table));
195           else if (RequestNo == USB_CCID_REQ_GET_DATA_RATES)
196             usb_lld_set_data_to_send (data_rate_table, sizeof (data_rate_table));
197         }
198 #ifdef ENABLE_VIRTUAL_COM_PORT
199       else if (index == 1)
200         vcom_port_data_setup (RequestNo);
201 #endif
202 #ifdef PINPAD_DND_SUPPORT
203       else if (index == MSC_INTERFACE_NO)
204         {
205           if (RequestNo == MSC_GET_MAX_LUN_COMMAND)
206             usb_lld_set_data_to_send (lun_table, sizeof (lun_table));
207         }
208 #endif
209     }
210 }
211
212
213 static int
214 gnuk_setup_with_nodata (uint8_t recipient, uint8_t RequestNo, uint16_t index)
215 {
216   if (recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT)) /* Interface */
217     if (index == 0)
218       {
219         if (RequestNo == USB_CCID_REQ_ABORT)
220           /* wValue: bSeq, bSlot */
221           /* Abortion is not supported in Gnuk */
222           return USB_UNSUPPORT;
223         else
224           return USB_UNSUPPORT;
225       }
226 #ifdef ENABLE_VIRTUAL_COM_PORT
227     else if (index == 1)
228       return vcom_port_setup_with_nodata (RequestNo);
229 #endif
230 #ifdef PINPAD_DND_SUPPORT
231     else if (index == MSC_INTERFACE_NO)
232       {
233         if (RequestNo == MSC_MASS_STORAGE_RESET_COMMAND)
234           {
235             /* Should call resetting MSC thread, something like msc_reset() */
236             return USB_SUCCESS;
237           }
238         else
239           return USB_UNSUPPORT;
240       }
241 #endif
242     else
243       return USB_UNSUPPORT;
244   else
245     return USB_UNSUPPORT;
246 }
247
248 static int
249 gnuk_get_descriptor (uint8_t desc_type, uint16_t index, uint16_t value)
250 {
251   (void)index;
252   if (desc_type == DEVICE_DESCRIPTOR)
253     {
254       usb_lld_set_data_to_send (Device_Descriptor.Descriptor,
255                                 Device_Descriptor.Descriptor_Size);
256       return USB_SUCCESS;
257     }
258   else if (desc_type == CONFIG_DESCRIPTOR)
259     {
260       usb_lld_set_data_to_send (Config_Descriptor.Descriptor,
261                                 Config_Descriptor.Descriptor_Size);
262       return USB_SUCCESS;
263     }
264   else if (desc_type == STRING_DESCRIPTOR)
265     {
266       uint8_t desc_index = value & 0xff;
267
268       if (desc_index < NUM_STRING_DESC)
269         {
270           usb_lld_set_data_to_send (String_Descriptors[desc_index].Descriptor,
271                             String_Descriptors[desc_index].Descriptor_Size);
272           return USB_SUCCESS;
273         }
274     }
275
276   return USB_UNSUPPORT;
277 }
278
279 static int gnuk_usb_event (uint8_t event_type, uint16_t value)
280 {
281   switch (event_type)
282     {
283     case USB_EVENT_RESET:
284       break;
285     case USB_EVENT_ADDRESS:
286       bDeviceState = ADDRESSED;
287       break;
288     case USB_EVENT_CONFIG:
289       if (usb_lld_current_configuration () == 0)
290         {
291           int i;
292           extern void *main_thread;
293 #define LED_STATUS_MODE   (8)
294
295           if (value != 1)
296             return USB_UNSUPPORT;
297
298           usb_lld_set_configuration (value);
299           for (i = 0; i < NUM_INTERFACES; i++)
300             gnuk_setup_endpoints_for_interface (i, 0);
301           bDeviceState = CONFIGURED;
302           chEvtSignalI (main_thread, LED_STATUS_MODE);
303           return USB_SUCCESS;
304         }
305       else
306         {
307           if (value != 0)
308             return USB_UNSUPPORT;
309
310           usb_lld_set_configuration (0);
311           for (i = 0; i < NUM_INTERFACES; i++)
312             gnuk_setup_endpoints_for_interface (i, 1);
313           bDeviceState = ADDRESSED;
314         }
315     default:
316       break;
317     }
318
319   return USB_UNSUPPORT;
320 }
321
322 static int gnuk_interface (uint8_t cmd, uint16_t interface, uint16_t alt)
323 {
324   static uint8_t zero = 0;
325
326   if (interface >= NUM_INTERFACES)
327     return USB_UNSUPPORT;
328
329   switch (cmd)
330     {
331     case USB_SET_INTERFACE:
332       if (alt != 0)
333         return USB_UNSUPPORT;
334       else
335         {
336           gnuk_setup_endpoints_for_interface (interface, 0);
337           return USB_SUCCESS;
338         }
339
340     case USB_GET_INTERFACE:
341       usb_lld_set_data_to_send (&zero, 1);
342       return USB_SUCCESS;
343
344     default:
345     case USB_QUERY_INTERFACE:
346       return USB_SUCCESS;
347     }
348 }
349
350 /*
351  * Interface to USB core
352  */
353
354 const struct usb_device_method Device_Method = {
355   gnuk_device_init,
356   gnuk_device_reset,
357   gnuk_setup_with_data,
358   gnuk_setup_with_nodata,
359   gnuk_get_descriptor,
360   gnuk_usb_event,
361   gnuk_interface,
362 };