Rev 3331 Rev 3332
1 /* Name: usbdrv.h 1 /* Name: usbdrv.h
2 * Project: AVR USB driver 2 * Project: AVR USB driver
3 * Author: Christian Starkjohann 3 * Author: Christian Starkjohann
4 * Creation Date: 2004-12-29 4 * Creation Date: 2004-12-29
5 * Tabsize: 4 5 * Tabsize: 4
6 * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH 6 * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
7 * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt) 7 * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
8 * This Revision: $Id: usbdrv.h,v 1.2 2007/05/19 12:30:11 harbaum Exp $ 8 * This Revision: $Id: usbdrv.h,v 1.2 2007/05/19 12:30:11 harbaum Exp $
9 */ 9 */
10   10  
11 #ifndef __usbdrv_h_included__ 11 #ifndef __usbdrv_h_included__
12 #define __usbdrv_h_included__ 12 #define __usbdrv_h_included__
13 #include "usbconfig.h" 13 #include "usbconfig.h"
14 #include "iarcompat.h" 14 #include "iarcompat.h"
15   15  
16 /* 16 /*
17 Hardware Prerequisites: 17 Hardware Prerequisites:
18 ======================= 18 =======================
19 USB lines D+ and D- MUST be wired to the same I/O port. D+ must (also) be 19 USB lines D+ and D- MUST be wired to the same I/O port. D+ must (also) be
20 connected to INT0. D- requires a pullup of 1.5k to +3.5V (and the device 20 connected to INT0. D- requires a pullup of 1.5k to +3.5V (and the device
21 must be powered at 3.5V) to identify as low-speed USB device. A pullup of 21 must be powered at 3.5V) to identify as low-speed USB device. A pullup of
22 1M SHOULD be connected from D+ to +3.5V to prevent interference when no USB 22 1M SHOULD be connected from D+ to +3.5V to prevent interference when no USB
23 master is connected. We use D+ as interrupt source and not D- because it 23 master is connected. We use D+ as interrupt source and not D- because it
24 does not trigger on keep-alive and RESET states. 24 does not trigger on keep-alive and RESET states.
25   25  
26 As a compile time option, the 1.5k pullup resistor on D- can be made 26 As a compile time option, the 1.5k pullup resistor on D- can be made
27 switchable to allow the device to disconnect at will. See the definition of 27 switchable to allow the device to disconnect at will. See the definition of
28 usbDeviceConnect() and usbDeviceDisconnect() further down in this file. 28 usbDeviceConnect() and usbDeviceDisconnect() further down in this file.
29   29  
30 Please adapt the values in usbconfig.h according to your hardware! 30 Please adapt the values in usbconfig.h according to your hardware!
31   31  
32 The device MUST be clocked at 12 MHz. This is more than the 10 MHz allowed by 32 The device MUST be clocked at 12 MHz. This is more than the 10 MHz allowed by
33 an AT90S2313 powered at 4.5V. However, if the supply voltage to maximum clock 33 an AT90S2313 powered at 4.5V. However, if the supply voltage to maximum clock
34 relation is interpolated linearly, an ATtiny2313 meets the requirement by 34 relation is interpolated linearly, an ATtiny2313 meets the requirement by
35 specification. In practice, the AT90S2313 can be overclocked and works well. 35 specification. In practice, the AT90S2313 can be overclocked and works well.
36   36  
37   37  
38 Limitations: 38 Limitations:
39 ============ 39 ============
40 Robustness with respect to communication errors: 40 Robustness with respect to communication errors:
41 The driver assumes error-free communication. It DOES check for errors in 41 The driver assumes error-free communication. It DOES check for errors in
42 the PID, but does NOT check bit stuffing errors, SE0 in middle of a byte, 42 the PID, but does NOT check bit stuffing errors, SE0 in middle of a byte,
43 token CRC (5 bit) and data CRC (16 bit). CRC checks can not be performed due 43 token CRC (5 bit) and data CRC (16 bit). CRC checks can not be performed due
44 to timing constraints: We must start sending a reply within 7 bit times. 44 to timing constraints: We must start sending a reply within 7 bit times.
45 Bit stuffing and misplaced SE0 would have to be checked in real-time, but CPU 45 Bit stuffing and misplaced SE0 would have to be checked in real-time, but CPU
46 performance does not permit that. The driver does not check Data0/Data1 46 performance does not permit that. The driver does not check Data0/Data1
47 toggling, but application software can implement the check. 47 toggling, but application software can implement the check.
48   48  
49 Input characteristics: 49 Input characteristics:
50 Since no differential receiver circuit is used, electrical interference 50 Since no differential receiver circuit is used, electrical interference
51 robustness may suffer. The driver samples only one of the data lines with 51 robustness may suffer. The driver samples only one of the data lines with
52 an ordinary I/O pin's input characteristics. However, since this is only a 52 an ordinary I/O pin's input characteristics. However, since this is only a
53 low speed USB implementation and the specification allows for 8 times the 53 low speed USB implementation and the specification allows for 8 times the
54 bit rate over the same hardware, we should be on the safe side. Even the spec 54 bit rate over the same hardware, we should be on the safe side. Even the spec
55 requires detection of asymmetric states at high bit rate for SE0 detection. 55 requires detection of asymmetric states at high bit rate for SE0 detection.
56   56  
57 Number of endpoints: 57 Number of endpoints:
58 The driver supports up to four endpoints: One control endpoint (endpoint 0), 58 The driver supports up to four endpoints: One control endpoint (endpoint 0),
59 two interrupt-in (or bulk-in) endpoints (endpoint 1 and 3) and one 59 two interrupt-in (or bulk-in) endpoints (endpoint 1 and 3) and one
60 interrupt-out (or bulk-out) endpoint (endpoint 1). Please note that the USB 60 interrupt-out (or bulk-out) endpoint (endpoint 1). Please note that the USB
61 standard forbids bulk endpoints for low speed devices! Most operating systems 61 standard forbids bulk endpoints for low speed devices! Most operating systems
62 allow them anyway, but the AVR will spend 90% of the CPU time in the USB 62 allow them anyway, but the AVR will spend 90% of the CPU time in the USB
63 interrupt polling for bulk data. 63 interrupt polling for bulk data.
64 By default, only the control endpoint 0 is enabled. To get the other endpoints, 64 By default, only the control endpoint 0 is enabled. To get the other endpoints,
65 define USB_CFG_HAVE_INTRIN_ENDPOINT, USB_CFG_HAVE_INTRIN_ENDPOINT3 and/or 65 define USB_CFG_HAVE_INTRIN_ENDPOINT, USB_CFG_HAVE_INTRIN_ENDPOINT3 and/or
66 USB_CFG_IMPLEMENT_FN_WRITEOUT respectively (see usbconfig-prototype.h for 66 USB_CFG_IMPLEMENT_FN_WRITEOUT respectively (see usbconfig-prototype.h for
67 details). 67 details).
68   68  
69 Maximum data payload: 69 Maximum data payload:
70 Data payload of control in and out transfers may be up to 254 bytes. In order 70 Data payload of control in and out transfers may be up to 254 bytes. In order
71 to accept payload data of out transfers, you need to implement 71 to accept payload data of out transfers, you need to implement
72 'usbFunctionWrite()'. 72 'usbFunctionWrite()'.
73   73  
74 USB Suspend Mode supply current: 74 USB Suspend Mode supply current:
75 The USB standard limits power consumption to 500uA when the bus is in suspend 75 The USB standard limits power consumption to 500uA when the bus is in suspend
76 mode. This is not a problem for self-powered devices since they don't need 76 mode. This is not a problem for self-powered devices since they don't need
77 bus power anyway. Bus-powered devices can achieve this only by putting the 77 bus power anyway. Bus-powered devices can achieve this only by putting the
78 CPU in sleep mode. The driver does not implement suspend handling by itself. 78 CPU in sleep mode. The driver does not implement suspend handling by itself.
79 However, the application may implement activity monitoring and wakeup from 79 However, the application may implement activity monitoring and wakeup from
80 sleep. The host sends regular SE0 states on the bus to keep it active. These 80 sleep. The host sends regular SE0 states on the bus to keep it active. These
81 SE0 states can be detected by wiring the INT1 pin to D-. It is not necessary 81 SE0 states can be detected by wiring the INT1 pin to D-. It is not necessary
82 to enable the interrupt, checking the interrupt pending flag should suffice. 82 to enable the interrupt, checking the interrupt pending flag should suffice.
83 Before entering sleep mode, the application should enable INT1 for a wakeup 83 Before entering sleep mode, the application should enable INT1 for a wakeup
84 on the next bus activity. 84 on the next bus activity.
85   85  
86 Operation without an USB master: 86 Operation without an USB master:
87 The driver behaves neutral without connection to an USB master if D- reads 87 The driver behaves neutral without connection to an USB master if D- reads
88 as 1. To avoid spurious interrupts, we recommend a high impedance (e.g. 1M) 88 as 1. To avoid spurious interrupts, we recommend a high impedance (e.g. 1M)
89 pullup resistor on D+. If D- becomes statically 0, the driver may block in 89 pullup resistor on D+. If D- becomes statically 0, the driver may block in
90 the interrupt routine. 90 the interrupt routine.
91   91  
92 Interrupt latency: 92 Interrupt latency:
93 The application must ensure that the USB interrupt is not disabled for more 93 The application must ensure that the USB interrupt is not disabled for more
94 than 20 cycles. This implies that all interrupt routines must either be 94 than 20 cycles. This implies that all interrupt routines must either be
95 declared as "INTERRUPT" instead of "SIGNAL" (see "avr/signal.h") or that they 95 declared as "INTERRUPT" instead of "SIGNAL" (see "avr/signal.h") or that they
96 are written in assembler with "sei" as the first instruction. 96 are written in assembler with "sei" as the first instruction.
97   97  
98 Maximum interrupt duration / CPU cycle consumption: 98 Maximum interrupt duration / CPU cycle consumption:
99 The driver handles all USB communication during the interrupt service 99 The driver handles all USB communication during the interrupt service
100 routine. The routine will not return before an entire USB message is received 100 routine. The routine will not return before an entire USB message is received
101 and the reply is sent. This may be up to ca. 1200 cycles = 100us if the host 101 and the reply is sent. This may be up to ca. 1200 cycles = 100us if the host
102 conforms to the standard. The driver will consume CPU cycles for all USB 102 conforms to the standard. The driver will consume CPU cycles for all USB
103 messages, even if they address another (low-speed) device on the same bus. 103 messages, even if they address another (low-speed) device on the same bus.
104   104  
105 */ 105 */
106   106  
107 /* ------------------------------------------------------------------------- */ 107 /* ------------------------------------------------------------------------- */
108 /* --------------------------- Module Interface ---------------------------- */ 108 /* --------------------------- Module Interface ---------------------------- */
109 /* ------------------------------------------------------------------------- */ 109 /* ------------------------------------------------------------------------- */
110   110  
111 #define USBDRV_VERSION 20070319 111 #define USBDRV_VERSION 20070319
112 /* This define uniquely identifies a driver version. It is a decimal number 112 /* This define uniquely identifies a driver version. It is a decimal number
113 * constructed from the driver's release date in the form YYYYMMDD. If the 113 * constructed from the driver's release date in the form YYYYMMDD. If the
114 * driver's behavior or interface changes, you can use this constant to 114 * driver's behavior or interface changes, you can use this constant to
115 * distinguish versions. If it is not defined, the driver's release date is 115 * distinguish versions. If it is not defined, the driver's release date is
116 * older than 2006-01-25. 116 * older than 2006-01-25.
117 */ 117 */
118   118  
119 #ifndef __ASSEMBLER__ 119 #ifndef __ASSEMBLER__
120   120  
121 #ifndef uchar 121 #ifndef uchar
122 #define uchar unsigned char 122 #define uchar unsigned char
123 #endif 123 #endif
124 #ifndef schar 124 #ifndef schar
125 #define schar signed char 125 #define schar signed char
126 #endif 126 #endif
127 /* shortcuts for well defined 8 bit integer types */ 127 /* shortcuts for well defined 8 bit integer types */
128   128  
129 struct usbRequest; /* forward declaration */ 129 struct usbRequest; /* forward declaration */
130   130  
131 extern void usbInit(void); 131 extern void usbInit(void);
132 /* This function must be called before interrupts are enabled and the main 132 /* This function must be called before interrupts are enabled and the main
133 * loop is entered. 133 * loop is entered.
134 */ 134 */
135 extern void usbPoll(void); 135 extern void usbPoll(void);
136 /* This function must be called at regular intervals from the main loop. 136 /* This function must be called at regular intervals from the main loop.
137 * Maximum delay between calls is somewhat less than 50ms (USB timeout for 137 * Maximum delay between calls is somewhat less than 50ms (USB timeout for
138 * accepting a Setup message). Otherwise the device will not be recognized. 138 * accepting a Setup message). Otherwise the device will not be recognized.
139 * Please note that debug outputs through the UART take ~ 0.5ms per byte 139 * Please note that debug outputs through the UART take ~ 0.5ms per byte
140 * at 19200 bps. 140 * at 19200 bps.
141 */ 141 */
142 extern uchar *usbMsgPtr; 142 extern uchar *usbMsgPtr;
143 /* This variable may be used to pass transmit data to the driver from the 143 /* This variable may be used to pass transmit data to the driver from the
144 * implementation of usbFunctionWrite(). It is also used internally by the 144 * implementation of usbFunctionWrite(). It is also used internally by the
145 * driver for standard control requests. 145 * driver for standard control requests.
146 */ 146 */
147 extern uchar usbFunctionSetup(uchar data[8]); 147 extern uchar usbFunctionSetup(uchar data[8]);
148 /* This function is called when the driver receives a SETUP transaction from 148 /* This function is called when the driver receives a SETUP transaction from
149 * the host which is not answered by the driver itself (in practice: class and 149 * the host which is not answered by the driver itself (in practice: class and
150 * vendor requests). All control transfers start with a SETUP transaction where 150 * vendor requests). All control transfers start with a SETUP transaction where
151 * the host communicates the parameters of the following (optional) data 151 * the host communicates the parameters of the following (optional) data
152 * transfer. The SETUP data is available in the 'data' parameter which can 152 * transfer. The SETUP data is available in the 'data' parameter which can
153 * (and should) be casted to 'usbRequest_t *' for a more user-friendly access 153 * (and should) be casted to 'usbRequest_t *' for a more user-friendly access
154 * to parameters. 154 * to parameters.
155 * 155 *
156 * If the SETUP indicates a control-in transfer, you should provide the 156 * If the SETUP indicates a control-in transfer, you should provide the
157 * requested data to the driver. There are two ways to transfer this data: 157 * requested data to the driver. There are two ways to transfer this data:
158 * (1) Set the global pointer 'usbMsgPtr' to the base of the static RAM data 158 * (1) Set the global pointer 'usbMsgPtr' to the base of the static RAM data
159 * block and return the length of the data in 'usbFunctionSetup()'. The driver 159 * block and return the length of the data in 'usbFunctionSetup()'. The driver
160 * will handle the rest. Or (2) return 0xff in 'usbFunctionSetup()'. The driver 160 * will handle the rest. Or (2) return 0xff in 'usbFunctionSetup()'. The driver
161 * will then call 'usbFunctionRead()' when data is needed. See the 161 * will then call 'usbFunctionRead()' when data is needed. See the
162 * documentation for usbFunctionRead() for details. 162 * documentation for usbFunctionRead() for details.
163 * 163 *
164 * If the SETUP indicates a control-out transfer, the only way to receive the 164 * If the SETUP indicates a control-out transfer, the only way to receive the
165 * data from the host is through the 'usbFunctionWrite()' call. If you 165 * data from the host is through the 'usbFunctionWrite()' call. If you
166 * implement this function, you must return 0xff in 'usbFunctionSetup()' to 166 * implement this function, you must return 0xff in 'usbFunctionSetup()' to
167 * indicate that 'usbFunctionWrite()' should be used. See the documentation of 167 * indicate that 'usbFunctionWrite()' should be used. See the documentation of
168 * this function for more information. If you just want to ignore the data sent 168 * this function for more information. If you just want to ignore the data sent
169 * by the host, return 0 in 'usbFunctionSetup()'. 169 * by the host, return 0 in 'usbFunctionSetup()'.
170 * 170 *
171 * Note that calls to the functions usbFunctionRead() and usbFunctionWrite() 171 * Note that calls to the functions usbFunctionRead() and usbFunctionWrite()
172 * are only done if enabled by the configuration in usbconfig.h. 172 * are only done if enabled by the configuration in usbconfig.h.
173 */ 173 */
174 extern uchar usbFunctionDescriptor(struct usbRequest *rq); 174 extern uchar usbFunctionDescriptor(struct usbRequest *rq);
175 /* You need to implement this function ONLY if you provide USB descriptors at 175 /* You need to implement this function ONLY if you provide USB descriptors at
176 * runtime (which is an expert feature). It is very similar to 176 * runtime (which is an expert feature). It is very similar to
177 * usbFunctionSetup() above, but it is called only to request USB descriptor 177 * usbFunctionSetup() above, but it is called only to request USB descriptor
178 * data. See the documentation of usbFunctionSetup() above for more info. 178 * data. See the documentation of usbFunctionSetup() above for more info.
179 */ 179 */
180 #if USB_CFG_HAVE_INTRIN_ENDPOINT 180 #if USB_CFG_HAVE_INTRIN_ENDPOINT
181 void usbSetInterrupt(uchar *data, uchar len); 181 void usbSetInterrupt(uchar *data, uchar len);
182 /* This function sets the message which will be sent during the next interrupt 182 /* This function sets the message which will be sent during the next interrupt
183 * IN transfer. The message is copied to an internal buffer and must not exceed 183 * IN transfer. The message is copied to an internal buffer and must not exceed
184 * a length of 8 bytes. The message may be 0 bytes long just to indicate the 184 * a length of 8 bytes. The message may be 0 bytes long just to indicate the
185 * interrupt status to the host. 185 * interrupt status to the host.
186 * If you need to transfer more bytes, use a control read after the interrupt. 186 * If you need to transfer more bytes, use a control read after the interrupt.
187 */ 187 */
188 extern volatile uchar usbTxLen1; 188 extern volatile uchar usbTxLen1;
189 #define usbInterruptIsReady() (usbTxLen1 & 0x10) 189 #define usbInterruptIsReady() (usbTxLen1 & 0x10)
190 /* This macro indicates whether the last interrupt message has already been 190 /* This macro indicates whether the last interrupt message has already been
191 * sent. If you set a new interrupt message before the old was sent, the 191 * sent. If you set a new interrupt message before the old was sent, the
192 * message already buffered will be lost. 192 * message already buffered will be lost.
193 */ 193 */
194 #if USB_CFG_HAVE_INTRIN_ENDPOINT3 194 #if USB_CFG_HAVE_INTRIN_ENDPOINT3
195 void usbSetInterrupt3(uchar *data, uchar len); 195 void usbSetInterrupt3(uchar *data, uchar len);
196 extern volatile uchar usbTxLen3; 196 extern volatile uchar usbTxLen3;
197 #define usbInterruptIsReady3() (usbTxLen3 & 0x10) 197 #define usbInterruptIsReady3() (usbTxLen3 & 0x10)
198 /* Same as above for endpoint 3 */ 198 /* Same as above for endpoint 3 */
199 #endif 199 #endif
200 #endif /* USB_CFG_HAVE_INTRIN_ENDPOINT */ 200 #endif /* USB_CFG_HAVE_INTRIN_ENDPOINT */
201 #if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* simplified interface for backward compatibility */ 201 #if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* simplified interface for backward compatibility */
202 #define usbHidReportDescriptor usbDescriptorHidReport 202 #define usbHidReportDescriptor usbDescriptorHidReport
203 /* should be declared as: PROGMEM char usbHidReportDescriptor[]; */ 203 /* should be declared as: PROGMEM char usbHidReportDescriptor[]; */
204 /* If you implement an HID device, you need to provide a report descriptor. 204 /* If you implement an HID device, you need to provide a report descriptor.
205 * The HID report descriptor syntax is a bit complex. If you understand how 205 * The HID report descriptor syntax is a bit complex. If you understand how
206 * report descriptors are constructed, we recommend that you use the HID 206 * report descriptors are constructed, we recommend that you use the HID
207 * Descriptor Tool from usb.org, see http://www.usb.org/developers/hidpage/. 207 * Descriptor Tool from usb.org, see http://www.usb.org/developers/hidpage/.
208 * Otherwise you should probably start with a working example. 208 * Otherwise you should probably start with a working example.
209 */ 209 */
210 #endif /* USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH */ 210 #endif /* USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH */
211 #if USB_CFG_IMPLEMENT_FN_WRITE 211 #if USB_CFG_IMPLEMENT_FN_WRITE
212 extern uchar usbFunctionWrite(uchar *data, uchar len); 212 extern uchar usbFunctionWrite(uchar *data, uchar len);
213 /* This function is called by the driver to provide a control transfer's 213 /* This function is called by the driver to provide a control transfer's
214 * payload data (control-out). It is called in chunks of up to 8 bytes. The 214 * payload data (control-out). It is called in chunks of up to 8 bytes. The
215 * total count provided in the current control transfer can be obtained from 215 * total count provided in the current control transfer can be obtained from
216 * the 'length' property in the setup data. If an error occurred during 216 * the 'length' property in the setup data. If an error occurred during
217 * processing, return 0xff (== -1). The driver will answer the entire transfer 217 * processing, return 0xff (== -1). The driver will answer the entire transfer
218 * with a STALL token in this case. If you have received the entire payload 218 * with a STALL token in this case. If you have received the entire payload
219 * successfully, return 1. If you expect more data, return 0. If you don't 219 * successfully, return 1. If you expect more data, return 0. If you don't
220 * know whether the host will send more data (you should know, the total is 220 * know whether the host will send more data (you should know, the total is
221 * provided in the usbFunctionSetup() call!), return 1. 221 * provided in the usbFunctionSetup() call!), return 1.
222 * NOTE: If you return 0xff for STALL, 'usbFunctionWrite()' may still be called 222 * NOTE: If you return 0xff for STALL, 'usbFunctionWrite()' may still be called
223 * for the remaining data. You must continue to return 0xff for STALL in these 223 * for the remaining data. You must continue to return 0xff for STALL in these
224 * calls. 224 * calls.
225 * In order to get usbFunctionWrite() called, define USB_CFG_IMPLEMENT_FN_WRITE 225 * In order to get usbFunctionWrite() called, define USB_CFG_IMPLEMENT_FN_WRITE
226 * to 1 in usbconfig.h and return 0xff in usbFunctionSetup().. 226 * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
227 */ 227 */
228 #endif /* USB_CFG_IMPLEMENT_FN_WRITE */ 228 #endif /* USB_CFG_IMPLEMENT_FN_WRITE */
229 #if USB_CFG_IMPLEMENT_FN_READ 229 #if USB_CFG_IMPLEMENT_FN_READ
230 extern uchar usbFunctionRead(uchar *data, uchar len); 230 extern uchar usbFunctionRead(uchar *data, uchar len);
231 /* This function is called by the driver to ask the application for a control 231 /* This function is called by the driver to ask the application for a control
232 * transfer's payload data (control-in). It is called in chunks of up to 8 232 * transfer's payload data (control-in). It is called in chunks of up to 8
233 * bytes each. You should copy the data to the location given by 'data' and 233 * bytes each. You should copy the data to the location given by 'data' and
234 * return the actual number of bytes copied. If you return less than requested, 234 * return the actual number of bytes copied. If you return less than requested,
235 * the control-in transfer is terminated. If you return 0xff, the driver aborts 235 * the control-in transfer is terminated. If you return 0xff, the driver aborts
236 * the transfer with a STALL token. 236 * the transfer with a STALL token.
237 * In order to get usbFunctionRead() called, define USB_CFG_IMPLEMENT_FN_READ 237 * In order to get usbFunctionRead() called, define USB_CFG_IMPLEMENT_FN_READ
238 * to 1 in usbconfig.h and return 0xff in usbFunctionSetup().. 238 * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
239 */ 239 */
240 #endif /* USB_CFG_IMPLEMENT_FN_READ */ 240 #endif /* USB_CFG_IMPLEMENT_FN_READ */
241 #if USB_CFG_IMPLEMENT_FN_WRITEOUT 241 #if USB_CFG_IMPLEMENT_FN_WRITEOUT
242 extern void usbFunctionWriteOut(uchar *data, uchar len); 242 extern void usbFunctionWriteOut(uchar *data, uchar len);
243 /* This function is called by the driver when data on interrupt-out or bulk- 243 /* This function is called by the driver when data on interrupt-out or bulk-
244 * out endpoint 1 is received. You must define USB_CFG_IMPLEMENT_FN_WRITEOUT 244 * out endpoint 1 is received. You must define USB_CFG_IMPLEMENT_FN_WRITEOUT
245 * to 1 in usbconfig.h to get this function called. 245 * to 1 in usbconfig.h to get this function called.
246 */ 246 */
247 #endif /* USB_CFG_IMPLEMENT_FN_WRITEOUT */ 247 #endif /* USB_CFG_IMPLEMENT_FN_WRITEOUT */
248 #ifdef USB_CFG_PULLUP_IOPORTNAME 248 #ifdef USB_CFG_PULLUP_IOPORTNAME
249 #define usbDeviceConnect() ((USB_PULLUP_DDR |= (1<<USB_CFG_PULLUP_BIT)), \ 249 #define usbDeviceConnect() ((USB_PULLUP_DDR |= (1<<USB_CFG_PULLUP_BIT)), \
250 (USB_PULLUP_OUT |= (1<<USB_CFG_PULLUP_BIT))) 250 (USB_PULLUP_OUT |= (1<<USB_CFG_PULLUP_BIT)))
251 /* This macro (intended to look like a function) connects the device to the 251 /* This macro (intended to look like a function) connects the device to the
252 * USB bus. It is only available if you have defined the constants 252 * USB bus. It is only available if you have defined the constants
253 * USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT in usbconfig.h. 253 * USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT in usbconfig.h.
254 */ 254 */
255 #define usbDeviceDisconnect() ((USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT)), \ 255 #define usbDeviceDisconnect() ((USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT)), \
256 (USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT))) 256 (USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT)))
257 /* This macro (intended to look like a function) disconnects the device from 257 /* This macro (intended to look like a function) disconnects the device from
258 * the USB bus. It is only available if you have defined the constants 258 * the USB bus. It is only available if you have defined the constants
259 * USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT in usbconfig.h. 259 * USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT in usbconfig.h.
260 */ 260 */
261 #endif /* USB_CFG_PULLUP_IOPORT */ 261 #endif /* USB_CFG_PULLUP_IOPORT */
262 extern unsigned usbCrc16(unsigned data, uchar len); 262 extern unsigned usbCrc16(unsigned data, uchar len);
263 #define usbCrc16(data, len) usbCrc16((unsigned)(data), len) 263 #define usbCrc16(data, len) usbCrc16((unsigned)(data), len)
264 /* This function calculates the binary complement of the data CRC used in 264 /* This function calculates the binary complement of the data CRC used in
265 * USB data packets. The value is used to build raw transmit packets. 265 * USB data packets. The value is used to build raw transmit packets.
266 * You may want to use this function for data checksums or to verify received 266 * You may want to use this function for data checksums or to verify received
267 * data. We enforce 16 bit calling conventions for compatibility with IAR's 267 * data. We enforce 16 bit calling conventions for compatibility with IAR's
268 * tiny memory model. 268 * tiny memory model.
269 */ 269 */
270 extern unsigned usbCrc16Append(unsigned data, uchar len); 270 extern unsigned usbCrc16Append(unsigned data, uchar len);
271 #define usbCrc16Append(data, len) usbCrc16Append((unsigned)(data), len) 271 #define usbCrc16Append(data, len) usbCrc16Append((unsigned)(data), len)
272 /* This function is equivalent to usbCrc16() above, except that it appends 272 /* This function is equivalent to usbCrc16() above, except that it appends
273 * the 2 bytes CRC (lowbyte first) in the 'data' buffer after reading 'len' 273 * the 2 bytes CRC (lowbyte first) in the 'data' buffer after reading 'len'
274 * bytes. 274 * bytes.
275 */ 275 */
276 extern uchar usbConfiguration; 276 extern uchar usbConfiguration;
277 /* This value contains the current configuration set by the host. The driver 277 /* This value contains the current configuration set by the host. The driver
278 * allows setting and querying of this variable with the USB SET_CONFIGURATION 278 * allows setting and querying of this variable with the USB SET_CONFIGURATION
279 * and GET_CONFIGURATION requests, but does not use it otherwise. 279 * and GET_CONFIGURATION requests, but does not use it otherwise.
280 * You may want to reflect the "configured" status with a LED on the device or 280 * You may want to reflect the "configured" status with a LED on the device or
281 * switch on high power parts of the circuit only if the device is configured. 281 * switch on high power parts of the circuit only if the device is configured.
282 */ 282 */
283 #define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2*(stringLength)+2) | (3<<8)) 283 #define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2*(stringLength)+2) | (3<<8))
284 /* This macro builds a descriptor header for a string descriptor given the 284 /* This macro builds a descriptor header for a string descriptor given the
285 * string's length. See usbdrv.c for an example how to use it. 285 * string's length. See usbdrv.c for an example how to use it.
286 */ 286 */
287 #if USB_CFG_HAVE_FLOWCONTROL 287 #if USB_CFG_HAVE_FLOWCONTROL
288 extern volatile schar usbRxLen; 288 extern volatile schar usbRxLen;
289 #define usbDisableAllRequests() usbRxLen = -1 289 #define usbDisableAllRequests() usbRxLen = -1
290 /* Must be called from usbFunctionWrite(). This macro disables all data input 290 /* Must be called from usbFunctionWrite(). This macro disables all data input
291 * from the USB interface. Requests from the host are answered with a NAK 291 * from the USB interface. Requests from the host are answered with a NAK
292 * while they are disabled. 292 * while they are disabled.
293 */ 293 */
294 #define usbEnableAllRequests() usbRxLen = 0 294 #define usbEnableAllRequests() usbRxLen = 0
295 /* May only be called if requests are disabled. This macro enables input from 295 /* May only be called if requests are disabled. This macro enables input from
296 * the USB interface after it has been disabled with usbDisableAllRequests(). 296 * the USB interface after it has been disabled with usbDisableAllRequests().
297 */ 297 */
298 #define usbAllRequestsAreDisabled() (usbRxLen < 0) 298 #define usbAllRequestsAreDisabled() (usbRxLen < 0)
299 /* Use this macro to find out whether requests are disabled. It may be needed 299 /* Use this macro to find out whether requests are disabled. It may be needed
300 * to ensure that usbEnableAllRequests() is never called when requests are 300 * to ensure that usbEnableAllRequests() is never called when requests are
301 * enabled. 301 * enabled.
302 */ 302 */
303 #endif 303 #endif
304   304  
305 #define USB_SET_DATATOKEN1(token) usbTxBuf1[0] = token 305 #define USB_SET_DATATOKEN1(token) usbTxBuf1[0] = token
306 #define USB_SET_DATATOKEN3(token) usbTxBuf3[0] = token 306 #define USB_SET_DATATOKEN3(token) usbTxBuf3[0] = token
307 /* These two macros can be used by application software to reset data toggling 307 /* These two macros can be used by application software to reset data toggling
308 * for interrupt-in endpoints 1 and 3. 308 * for interrupt-in endpoints 1 and 3.
309 */ 309 */
310   310  
311 #endif /* __ASSEMBLER__ */ 311 #endif /* __ASSEMBLER__ */
312   312  
313   313  
314 /* ------------------------------------------------------------------------- */ 314 /* ------------------------------------------------------------------------- */
315 /* ----------------- Definitions for Descriptor Properties ----------------- */ 315 /* ----------------- Definitions for Descriptor Properties ----------------- */
316 /* ------------------------------------------------------------------------- */ 316 /* ------------------------------------------------------------------------- */
317 /* This is advanced stuff. See usbconfig-prototype.h for more information 317 /* This is advanced stuff. See usbconfig-prototype.h for more information
318 * about the various methods to define USB descriptors. If you do nothing, 318 * about the various methods to define USB descriptors. If you do nothing,
319 * the default descriptors will be used. 319 * the default descriptors will be used.
320 */ 320 */
321 #define USB_PROP_IS_DYNAMIC (1 << 8) 321 #define USB_PROP_IS_DYNAMIC (1 << 8)
322 /* If this property is set for a descriptor, usbFunctionDescriptor() will be 322 /* If this property is set for a descriptor, usbFunctionDescriptor() will be
323 * used to obtain the particular descriptor. 323 * used to obtain the particular descriptor.
324 */ 324 */
325 #define USB_PROP_IS_RAM (1 << 9) 325 #define USB_PROP_IS_RAM (1 << 9)
326 /* If this property is set for a descriptor, the data is read from RAM 326 /* If this property is set for a descriptor, the data is read from RAM
327 * memory instead of Flash. The property is used for all methods to provide 327 * memory instead of Flash. The property is used for all methods to provide
328 * external descriptors. 328 * external descriptors.
329 */ 329 */
330 #define USB_PROP_LENGTH(len) ((len) & 0xff) 330 #define USB_PROP_LENGTH(len) ((len) & 0xff)
331 /* If a static external descriptor is used, this is the total length of the 331 /* If a static external descriptor is used, this is the total length of the
332 * descriptor in bytes. 332 * descriptor in bytes.
333 */ 333 */
334   334  
335 /* all descriptors which may have properties: */ 335 /* all descriptors which may have properties: */
336 #ifndef USB_CFG_DESCR_PROPS_DEVICE 336 #ifndef USB_CFG_DESCR_PROPS_DEVICE
337 #define USB_CFG_DESCR_PROPS_DEVICE 0 337 #define USB_CFG_DESCR_PROPS_DEVICE 0
338 #endif 338 #endif
339 #ifndef USB_CFG_DESCR_PROPS_CONFIGURATION 339 #ifndef USB_CFG_DESCR_PROPS_CONFIGURATION
340 #define USB_CFG_DESCR_PROPS_CONFIGURATION 0 340 #define USB_CFG_DESCR_PROPS_CONFIGURATION 0
341 #endif 341 #endif
342 #ifndef USB_CFG_DESCR_PROPS_STRINGS 342 #ifndef USB_CFG_DESCR_PROPS_STRINGS
343 #define USB_CFG_DESCR_PROPS_STRINGS 0 343 #define USB_CFG_DESCR_PROPS_STRINGS 0
344 #endif 344 #endif
345 #ifndef USB_CFG_DESCR_PROPS_STRING_0 345 #ifndef USB_CFG_DESCR_PROPS_STRING_0
346 #define USB_CFG_DESCR_PROPS_STRING_0 0 346 #define USB_CFG_DESCR_PROPS_STRING_0 0
347 #endif 347 #endif
348 #ifndef USB_CFG_DESCR_PROPS_STRING_VENDOR 348 #ifndef USB_CFG_DESCR_PROPS_STRING_VENDOR
349 #define USB_CFG_DESCR_PROPS_STRING_VENDOR 0 349 #define USB_CFG_DESCR_PROPS_STRING_VENDOR 0
350 #endif 350 #endif
351 #ifndef USB_CFG_DESCR_PROPS_STRING_DEVICE 351 #ifndef USB_CFG_DESCR_PROPS_STRING_DEVICE
352 #define USB_CFG_DESCR_PROPS_STRING_DEVICE 0 352 #define USB_CFG_DESCR_PROPS_STRING_DEVICE 0
353 #endif 353 #endif
354 #ifndef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 354 #ifndef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
355 #define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0 355 #define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0
356 #endif 356 #endif
357 #ifndef USB_CFG_DESCR_PROPS_HID 357 #ifndef USB_CFG_DESCR_PROPS_HID
358 #define USB_CFG_DESCR_PROPS_HID 0 358 #define USB_CFG_DESCR_PROPS_HID 0
359 #endif 359 #endif
360 #if !(USB_CFG_DESCR_PROPS_HID_REPORT) 360 #if !(USB_CFG_DESCR_PROPS_HID_REPORT)
361 # undef USB_CFG_DESCR_PROPS_HID_REPORT 361 # undef USB_CFG_DESCR_PROPS_HID_REPORT
362 # if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */ 362 # if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */
363 # define USB_CFG_DESCR_PROPS_HID_REPORT USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH 363 # define USB_CFG_DESCR_PROPS_HID_REPORT USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
364 # else 364 # else
365 # define USB_CFG_DESCR_PROPS_HID_REPORT 0 365 # define USB_CFG_DESCR_PROPS_HID_REPORT 0
366 # endif 366 # endif
367 #endif 367 #endif
368 #ifndef USB_CFG_DESCR_PROPS_UNKNOWN 368 #ifndef USB_CFG_DESCR_PROPS_UNKNOWN
369 #define USB_CFG_DESCR_PROPS_UNKNOWN 0 369 #define USB_CFG_DESCR_PROPS_UNKNOWN 0
370 #endif 370 #endif
371   371  
372 /* ------------------ forward declaration of descriptors ------------------- */ 372 /* ------------------ forward declaration of descriptors ------------------- */
373 /* If you use external static descriptors, they must be stored in global 373 /* If you use external static descriptors, they must be stored in global
374 * arrays as declared below: 374 * arrays as declared below:
375 */ 375 */
376 #ifndef __ASSEMBLER__ 376 #ifndef __ASSEMBLER__
377 extern 377 extern
378 #if !(USB_CFG_DESCR_PROPS_DEVICE & USB_PROP_IS_RAM) 378 #if !(USB_CFG_DESCR_PROPS_DEVICE & USB_PROP_IS_RAM)
379 PROGMEM 379 PROGMEM
380 #endif 380 #endif
381 char usbDescriptorDevice[]; 381 char usbDescriptorDevice[];
382   382  
383 extern 383 extern
384 #if !(USB_CFG_DESCR_PROPS_CONFIGURATION & USB_PROP_IS_RAM) 384 #if !(USB_CFG_DESCR_PROPS_CONFIGURATION & USB_PROP_IS_RAM)
385 PROGMEM 385 PROGMEM
386 #endif 386 #endif
387 char usbDescriptorConfiguration[]; 387 char usbDescriptorConfiguration[];
388   388  
389 extern 389 extern
390 #if !(USB_CFG_DESCR_PROPS_HID_REPORT & USB_PROP_IS_RAM) 390 #if !(USB_CFG_DESCR_PROPS_HID_REPORT & USB_PROP_IS_RAM)
391 PROGMEM 391 PROGMEM
392 #endif 392 #endif
393 char usbDescriptorHidReport[]; 393 char usbDescriptorHidReport[];
394   394  
395 extern 395 extern
396 #if !(USB_CFG_DESCR_PROPS_STRING_0 & USB_PROP_IS_RAM) 396 #if !(USB_CFG_DESCR_PROPS_STRING_0 & USB_PROP_IS_RAM)
397 PROGMEM 397 PROGMEM
398 #endif 398 #endif
399 char usbDescriptorString0[]; 399 char usbDescriptorString0[];
400   400  
401 extern 401 extern
402 #if !(USB_CFG_DESCR_PROPS_STRING_VENDOR & USB_PROP_IS_RAM) 402 #if !(USB_CFG_DESCR_PROPS_STRING_VENDOR & USB_PROP_IS_RAM)
403 PROGMEM 403 PROGMEM
404 #endif 404 #endif
405 int usbDescriptorStringVendor[]; 405 int usbDescriptorStringVendor[];
406   406  
407 extern 407 extern
408 #if !(USB_CFG_DESCR_PROPS_STRING_PRODUCT & USB_PROP_IS_RAM) 408 #if !(USB_CFG_DESCR_PROPS_STRING_PRODUCT & USB_PROP_IS_RAM)
409 PROGMEM 409 PROGMEM
410 #endif 410 #endif
411 int usbDescriptorStringDevice[]; 411 int usbDescriptorStringDevice[];
412   412  
413 extern 413 extern
414 #if !(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER & USB_PROP_IS_RAM) 414 #if !(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER & USB_PROP_IS_RAM)
415 PROGMEM 415 PROGMEM
416 #endif 416 #endif
417 int usbDescriptorStringSerialNumber[]; 417 int usbDescriptorStringSerialNumber[];
418   418  
419 #endif /* __ASSEMBLER__ */ 419 #endif /* __ASSEMBLER__ */
420   420  
421 /* ------------------------------------------------------------------------- */ 421 /* ------------------------------------------------------------------------- */
422 /* ------------------------ General Purpose Macros ------------------------- */ 422 /* ------------------------ General Purpose Macros ------------------------- */
423 /* ------------------------------------------------------------------------- */ 423 /* ------------------------------------------------------------------------- */
424   424  
425 #define USB_CONCAT(a, b) a ## b 425 #define USB_CONCAT(a, b) a ## b
426 #define USB_CONCAT_EXPANDED(a, b) USB_CONCAT(a, b) 426 #define USB_CONCAT_EXPANDED(a, b) USB_CONCAT(a, b)
427   427  
428 #define USB_OUTPORT(name) USB_CONCAT(PORT, name) 428 #define USB_OUTPORT(name) USB_CONCAT(PORT, name)
429 #define USB_INPORT(name) USB_CONCAT(PIN, name) 429 #define USB_INPORT(name) USB_CONCAT(PIN, name)
430 #define USB_DDRPORT(name) USB_CONCAT(DDR, name) 430 #define USB_DDRPORT(name) USB_CONCAT(DDR, name)
431 /* The double-define trick above lets us concatenate strings which are 431 /* The double-define trick above lets us concatenate strings which are
432 * defined by macros. 432 * defined by macros.
433 */ 433 */
434   434  
435 /* ------------------------------------------------------------------------- */ 435 /* ------------------------------------------------------------------------- */
436 /* ------------------------- Constant definitions -------------------------- */ 436 /* ------------------------- Constant definitions -------------------------- */
437 /* ------------------------------------------------------------------------- */ 437 /* ------------------------------------------------------------------------- */
438   438  
439 #if !defined __ASSEMBLER__ && (!defined USB_CFG_VENDOR_ID || !defined USB_CFG_DEVICE_ID) 439 #if !defined __ASSEMBLER__ && (!defined USB_CFG_VENDOR_ID || !defined USB_CFG_DEVICE_ID)
440 #warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h" 440 #warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h"
441 /* If the user has not defined IDs, we default to obdev's free IDs. 441 /* If the user has not defined IDs, we default to obdev's free IDs.
442 * See USBID-License.txt for details. 442 * See USBID-License.txt for details.
443 */ 443 */
444 #endif 444 #endif
445   445  
446 /* make sure we have a VID and PID defined, byte order is lowbyte, highbyte */ 446 /* make sure we have a VID and PID defined, byte order is lowbyte, highbyte */
447 #ifndef USB_CFG_VENDOR_ID 447 #ifndef USB_CFG_VENDOR_ID
448 # define USB_CFG_VENDOR_ID 0xc0, 0x16 /* 5824 in dec, stands for VOTI */ 448 # define USB_CFG_VENDOR_ID 0xc0, 0x16 /* 5824 in dec, stands for VOTI */
449 #endif 449 #endif
450   450  
451 #ifndef USB_CFG_DEVICE_ID 451 #ifndef USB_CFG_DEVICE_ID
452 # if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH 452 # if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
453 # define USB_CFG_DEVICE_ID 0xdf, 0x05 /* 1503 in dec, shared PID for HIDs */ 453 # define USB_CFG_DEVICE_ID 0xdf, 0x05 /* 1503 in dec, shared PID for HIDs */
454 # elif USB_CFG_INTERFACE_CLASS == 2 454 # elif USB_CFG_INTERFACE_CLASS == 2
455 # define USB_CFG_DEVICE_ID 0xe1, 0x05 /* 1505 in dec, shared PID for CDC Modems */ 455 # define USB_CFG_DEVICE_ID 0xe1, 0x05 /* 1505 in dec, shared PID for CDC Modems */
456 # else 456 # else
457 # define USB_CFG_DEVICE_ID 0xdc, 0x05 /* 1500 in dec, obdev's free PID */ 457 # define USB_CFG_DEVICE_ID 0xdc, 0x05 /* 1500 in dec, obdev's free PID */
458 # endif 458 # endif
459 #endif 459 #endif
460   460  
461 /* Derive Output, Input and DataDirection ports from port names */ 461 /* Derive Output, Input and DataDirection ports from port names */
462 #ifndef USB_CFG_IOPORTNAME 462 #ifndef USB_CFG_IOPORTNAME
463 #error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h" 463 #error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h"
464 #endif 464 #endif
465   465  
466 #define USBOUT USB_OUTPORT(USB_CFG_IOPORTNAME) 466 #define USBOUT USB_OUTPORT(USB_CFG_IOPORTNAME)
467 #define USB_PULLUP_OUT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME) 467 #define USB_PULLUP_OUT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
468 #define USBIN USB_INPORT(USB_CFG_IOPORTNAME) 468 #define USBIN USB_INPORT(USB_CFG_IOPORTNAME)
469 #define USBDDR USB_DDRPORT(USB_CFG_IOPORTNAME) 469 #define USBDDR USB_DDRPORT(USB_CFG_IOPORTNAME)
470 #define USB_PULLUP_DDR USB_DDRPORT(USB_CFG_PULLUP_IOPORTNAME) 470 #define USB_PULLUP_DDR USB_DDRPORT(USB_CFG_PULLUP_IOPORTNAME)
471   471  
472 #define USBMINUS USB_CFG_DMINUS_BIT 472 #define USBMINUS USB_CFG_DMINUS_BIT
473 #define USBPLUS USB_CFG_DPLUS_BIT 473 #define USBPLUS USB_CFG_DPLUS_BIT
474 #define USBIDLE (1<<USB_CFG_DMINUS_BIT) /* value representing J state */ 474 #define USBIDLE (1<<USB_CFG_DMINUS_BIT) /* value representing J state */
475 #define USBMASK ((1<<USB_CFG_DPLUS_BIT) | (1<<USB_CFG_DMINUS_BIT)) /* mask for USB I/O bits */ 475 #define USBMASK ((1<<USB_CFG_DPLUS_BIT) | (1<<USB_CFG_DMINUS_BIT)) /* mask for USB I/O bits */
476   476  
477 /* defines for backward compatibility with older driver versions: */ 477 /* defines for backward compatibility with older driver versions: */
478 #define USB_CFG_IOPORT USB_OUTPORT(USB_CFG_IOPORTNAME) 478 #define USB_CFG_IOPORT USB_OUTPORT(USB_CFG_IOPORTNAME)
479 #ifdef USB_CFG_PULLUP_IOPORTNAME 479 #ifdef USB_CFG_PULLUP_IOPORTNAME
480 #define USB_CFG_PULLUP_IOPORT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME) 480 #define USB_CFG_PULLUP_IOPORT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
481 #endif 481 #endif
482   482  
483   483  
484 #define USB_BUFSIZE 11 /* PID, 8 bytes data, 2 bytes CRC */ 484 #define USB_BUFSIZE 11 /* PID, 8 bytes data, 2 bytes CRC */
485   485  
486 /* ----- Try to find registers and bits responsible for ext interrupt 0 ----- */ 486 /* ----- Try to find registers and bits responsible for ext interrupt 0 ----- */
487   487  
488 #ifndef USB_INTR_CFG /* allow user to override our default */ 488 #ifndef USB_INTR_CFG /* allow user to override our default */
489 # if defined EICRA 489 # if defined EICRA
490 # define USB_INTR_CFG EICRA 490 # define USB_INTR_CFG EICRA
491 # else 491 # else
492 # define USB_INTR_CFG MCUCR 492 # define USB_INTR_CFG MCUCR
493 # endif 493 # endif
494 #endif 494 #endif
495 #ifndef USB_INTR_CFG_SET /* allow user to override our default */ 495 #ifndef USB_INTR_CFG_SET /* allow user to override our default */
496 # define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) /* cfg for rising edge */ 496 # define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) /* cfg for rising edge */
497 #endif 497 #endif
498 #ifndef USB_INTR_CFG_CLR /* allow user to override our default */ 498 #ifndef USB_INTR_CFG_CLR /* allow user to override our default */
499 # define USB_INTR_CFG_CLR 0 /* no bits to clear */ 499 # define USB_INTR_CFG_CLR 0 /* no bits to clear */
500 #endif 500 #endif
501   501  
502 #ifndef USB_INTR_ENABLE /* allow user to override our default */ 502 #ifndef USB_INTR_ENABLE /* allow user to override our default */
503 # if defined GIMSK 503 # if defined GIMSK
504 # define USB_INTR_ENABLE GIMSK 504 # define USB_INTR_ENABLE GIMSK
505 # elif defined EIMSK 505 # elif defined EIMSK
506 # define USB_INTR_ENABLE EIMSK 506 # define USB_INTR_ENABLE EIMSK
507 # else 507 # else
508 # define USB_INTR_ENABLE GICR 508 # define USB_INTR_ENABLE GICR
509 # endif 509 # endif
510 #endif 510 #endif
511 #ifndef USB_INTR_ENABLE_BIT /* allow user to override our default */ 511 #ifndef USB_INTR_ENABLE_BIT /* allow user to override our default */
512 # define USB_INTR_ENABLE_BIT INT0 512 # define USB_INTR_ENABLE_BIT INT0
513 #endif 513 #endif
514   514  
515 #ifndef USB_INTR_PENDING /* allow user to override our default */ 515 #ifndef USB_INTR_PENDING /* allow user to override our default */
516 # if defined EIFR 516 # if defined EIFR
517 # define USB_INTR_PENDING EIFR 517 # define USB_INTR_PENDING EIFR
518 # else 518 # else
519 # define USB_INTR_PENDING GIFR 519 # define USB_INTR_PENDING GIFR
520 # endif 520 # endif
521 #endif 521 #endif
522 #ifndef USB_INTR_PENDING_BIT /* allow user to override our default */ 522 #ifndef USB_INTR_PENDING_BIT /* allow user to override our default */
523 # define USB_INTR_PENDING_BIT INTF0 523 # define USB_INTR_PENDING_BIT INTF0
524 #endif 524 #endif
525   525  
526 /* 526 /*
527 The defines above don't work for the following chips 527 The defines above don't work for the following chips
528 at90c8534: no ISC0?, no PORTB, can't find a data sheet 528 at90c8534: no ISC0?, no PORTB, can't find a data sheet
529 at86rf401: no PORTB, no MCUCR etc, low clock rate 529 at86rf401: no PORTB, no MCUCR etc, low clock rate
530 atmega103: no ISC0? (maybe omission in header, can't find data sheet) 530 atmega103: no ISC0? (maybe omission in header, can't find data sheet)
531 atmega603: not defined in avr-libc 531 atmega603: not defined in avr-libc
532 at43usb320, at43usb355, at76c711: have USB anyway 532 at43usb320, at43usb355, at76c711: have USB anyway
533 at94k: is different... 533 at94k: is different...
534   534  
535 at90s1200, attiny11, attiny12, attiny15, attiny28: these have no RAM 535 at90s1200, attiny11, attiny12, attiny15, attiny28: these have no RAM
536 */ 536 */
537   537  
538 /* ------------------------------------------------------------------------- */ 538 /* ------------------------------------------------------------------------- */
539 /* ----------------- USB Specification Constants and Types ----------------- */ 539 /* ----------------- USB Specification Constants and Types ----------------- */
540 /* ------------------------------------------------------------------------- */ 540 /* ------------------------------------------------------------------------- */
541   541  
542 /* USB Token values */ 542 /* USB Token values */
543 #define USBPID_SETUP 0x2d 543 #define USBPID_SETUP 0x2d
544 #define USBPID_OUT 0xe1 544 #define USBPID_OUT 0xe1
545 #define USBPID_IN 0x69 545 #define USBPID_IN 0x69
546 #define USBPID_DATA0 0xc3 546 #define USBPID_DATA0 0xc3
547 #define USBPID_DATA1 0x4b 547 #define USBPID_DATA1 0x4b
548   548  
549 #define USBPID_ACK 0xd2 549 #define USBPID_ACK 0xd2
550 #define USBPID_NAK 0x5a 550 #define USBPID_NAK 0x5a
551 #define USBPID_STALL 0x1e 551 #define USBPID_STALL 0x1e
552   552  
553 #ifndef __ASSEMBLER__ 553 #ifndef __ASSEMBLER__
554   554  
555 extern uchar usbTxBuf1[USB_BUFSIZE], usbTxBuf3[USB_BUFSIZE]; 555 extern uchar usbTxBuf1[USB_BUFSIZE], usbTxBuf3[USB_BUFSIZE];
556   556  
557 typedef union usbWord{ 557 typedef union usbWord{
558 unsigned word; 558 unsigned word;
559 uchar bytes[2]; 559 uchar bytes[2];
560 }usbWord_t; 560 }usbWord_t;
561   561  
562 typedef struct usbRequest{ 562 typedef struct usbRequest{
563 uchar bmRequestType; 563 uchar bmRequestType;
564 uchar bRequest; 564 uchar bRequest;
565 usbWord_t wValue; 565 usbWord_t wValue;
566 usbWord_t wIndex; 566 usbWord_t wIndex;
567 usbWord_t wLength; 567 usbWord_t wLength;
568 }usbRequest_t; 568 }usbRequest_t;
569 /* This structure matches the 8 byte setup request */ 569 /* This structure matches the 8 byte setup request */
570 #endif 570 #endif
571   571  
572 /* bmRequestType field in USB setup: 572 /* bmRequestType field in USB setup:
573 * d t t r r r r r, where 573 * d t t r r r r r, where
574 * d ..... direction: 0=host->device, 1=device->host 574 * d ..... direction: 0=host->device, 1=device->host
575 * t ..... type: 0=standard, 1=class, 2=vendor, 3=reserved 575 * t ..... type: 0=standard, 1=class, 2=vendor, 3=reserved
576 * r ..... recipient: 0=device, 1=interface, 2=endpoint, 3=other 576 * r ..... recipient: 0=device, 1=interface, 2=endpoint, 3=other
577 */ 577 */
578   578  
579 /* USB setup recipient values */ 579 /* USB setup recipient values */
580 #define USBRQ_RCPT_MASK 0x1f 580 #define USBRQ_RCPT_MASK 0x1f
581 #define USBRQ_RCPT_DEVICE 0 581 #define USBRQ_RCPT_DEVICE 0
582 #define USBRQ_RCPT_INTERFACE 1 582 #define USBRQ_RCPT_INTERFACE 1
583 #define USBRQ_RCPT_ENDPOINT 2 583 #define USBRQ_RCPT_ENDPOINT 2
584   584  
585 /* USB request type values */ 585 /* USB request type values */
586 #define USBRQ_TYPE_MASK 0x60 586 #define USBRQ_TYPE_MASK 0x60
587 #define USBRQ_TYPE_STANDARD (0<<5) 587 #define USBRQ_TYPE_STANDARD (0<<5)
588 #define USBRQ_TYPE_CLASS (1<<5) 588 #define USBRQ_TYPE_CLASS (1<<5)
589 #define USBRQ_TYPE_VENDOR (2<<5) 589 #define USBRQ_TYPE_VENDOR (2<<5)
590   590  
591 /* USB direction values: */ 591 /* USB direction values: */
592 #define USBRQ_DIR_MASK 0x80 592 #define USBRQ_DIR_MASK 0x80
593 #define USBRQ_DIR_HOST_TO_DEVICE (0<<7) 593 #define USBRQ_DIR_HOST_TO_DEVICE (0<<7)
594 #define USBRQ_DIR_DEVICE_TO_HOST (1<<7) 594 #define USBRQ_DIR_DEVICE_TO_HOST (1<<7)
595   595  
596 /* USB Standard Requests */ 596 /* USB Standard Requests */
597 #define USBRQ_GET_STATUS 0 597 #define USBRQ_GET_STATUS 0
598 #define USBRQ_CLEAR_FEATURE 1 598 #define USBRQ_CLEAR_FEATURE 1
599 #define USBRQ_SET_FEATURE 3 599 #define USBRQ_SET_FEATURE 3
600 #define USBRQ_SET_ADDRESS 5 600 #define USBRQ_SET_ADDRESS 5
601 #define USBRQ_GET_DESCRIPTOR 6 601 #define USBRQ_GET_DESCRIPTOR 6
602 #define USBRQ_SET_DESCRIPTOR 7 602 #define USBRQ_SET_DESCRIPTOR 7
603 #define USBRQ_GET_CONFIGURATION 8 603 #define USBRQ_GET_CONFIGURATION 8
604 #define USBRQ_SET_CONFIGURATION 9 604 #define USBRQ_SET_CONFIGURATION 9
605 #define USBRQ_GET_INTERFACE 10 605 #define USBRQ_GET_INTERFACE 10
606 #define USBRQ_SET_INTERFACE 11 606 #define USBRQ_SET_INTERFACE 11
607 #define USBRQ_SYNCH_FRAME 12 607 #define USBRQ_SYNCH_FRAME 12
608   608  
609 /* USB descriptor constants */ 609 /* USB descriptor constants */
610 #define USBDESCR_DEVICE 1 610 #define USBDESCR_DEVICE 1
611 #define USBDESCR_CONFIG 2 611 #define USBDESCR_CONFIG 2
612 #define USBDESCR_STRING 3 612 #define USBDESCR_STRING 3
613 #define USBDESCR_INTERFACE 4 613 #define USBDESCR_INTERFACE 4
614 #define USBDESCR_ENDPOINT 5 614 #define USBDESCR_ENDPOINT 5
615 #define USBDESCR_HID 0x21 615 #define USBDESCR_HID 0x21
616 #define USBDESCR_HID_REPORT 0x22 616 #define USBDESCR_HID_REPORT 0x22
617 #define USBDESCR_HID_PHYS 0x23 617 #define USBDESCR_HID_PHYS 0x23
618   618  
619 #define USBATTR_BUSPOWER 0x80 619 #define USBATTR_BUSPOWER 0x80
620 #define USBATTR_SELFPOWER 0x40 620 #define USBATTR_SELFPOWER 0x40
621 #define USBATTR_REMOTEWAKE 0x20 621 #define USBATTR_REMOTEWAKE 0x20
622   622  
623 /* USB HID Requests */ 623 /* USB HID Requests */
624 #define USBRQ_HID_GET_REPORT 0x01 624 #define USBRQ_HID_GET_REPORT 0x01
625 #define USBRQ_HID_GET_IDLE 0x02 625 #define USBRQ_HID_GET_IDLE 0x02
626 #define USBRQ_HID_GET_PROTOCOL 0x03 626 #define USBRQ_HID_GET_PROTOCOL 0x03
627 #define USBRQ_HID_SET_REPORT 0x09 627 #define USBRQ_HID_SET_REPORT 0x09
628 #define USBRQ_HID_SET_IDLE 0x0a 628 #define USBRQ_HID_SET_IDLE 0x0a
629 #define USBRQ_HID_SET_PROTOCOL 0x0b 629 #define USBRQ_HID_SET_PROTOCOL 0x0b
630   630  
631 /* ------------------------------------------------------------------------- */ 631 /* ------------------------------------------------------------------------- */
632   632  
633 #endif /* __usbdrv_h_included__ */ 633 #endif /* __usbdrv_h_included__ */