DevChapter9.c 7.88 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
             LUFA Library
     Copyright (C) Dean Camera, 2009.
              
  dean [at] fourwalledcubicle [dot] com
      www.fourwalledcubicle.com
*/

/*
  Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)

  Permission to use, copy, modify, and distribute this software
  and its documentation for any purpose and without fee is hereby
  granted, provided that the above copyright notice appear in all
  copies and that both that the copyright notice and this
  permission notice and warranty disclaimer appear in supporting
  documentation, and that the name of the author not be used in
  advertising or publicity pertaining to distribution of the
  software without specific, written prior permission.

  The author disclaim all warranties with regard to this
  software, including all implied warranties of merchantability
  and fitness.  In no event shall the author be liable for any
  special, indirect or consequential damages or any damages
  whatsoever resulting from loss of use, data or profits, whether
  in an action of contract, negligence or other tortious action,
  arising out of or in connection with the use or performance of
  this software.
*/

31
32
#include "../HighLevel/USBMode.h"

33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#if defined(USB_CAN_BE_DEVICE)

#define  INCLUDE_FROM_DEVCHAPTER9_C
#include "DevChapter9.h"

uint8_t USB_ConfigurationNumber;
bool    USB_RemoteWakeupEnabled;
bool    USB_CurrentlySelfPowered;

void USB_Device_ProcessControlPacket(void)
{
	uint8_t bmRequestType  = Endpoint_Read_Byte();
	uint8_t bRequest       = Endpoint_Read_Byte();
	bool    RequestHandled = false;	
	
	switch (bRequest)
	{
		case REQ_GetStatus:
			if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
			    (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT)))
			{
				USB_Device_GetStatus(bmRequestType);
				RequestHandled = true;
			}

			break;
59
#if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
		case REQ_ClearFeature:
		case REQ_SetFeature:
			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT))
			{
				USB_Device_ClearSetFeature(bRequest, bmRequestType);
				RequestHandled = true;
			}

			break;
#endif
		case REQ_SetAddress:
			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
			{
				USB_Device_SetAddress();
				RequestHandled = true;
			}

			break;
		case REQ_GetDescriptor:
			if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
			    (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE)))
			{
				USB_Device_GetDescriptor();
				RequestHandled = true;
			}
			
			break;
		case REQ_GetConfiguration:
			if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
			{
				USB_Device_GetConfiguration();
				RequestHandled = true;
			}

			break;
		case REQ_SetConfiguration:
			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
			{
				USB_Device_SetConfiguration();
				RequestHandled = true;
			}

			break;
	}

	if (!(RequestHandled))
	  RAISE_EVENT(USB_UnhandledControlPacket, bRequest, bmRequestType);
	  
108
	if (Endpoint_IsSETUPReceived())
109
110
	{
		Endpoint_StallTransaction();
111
		Endpoint_ClearSETUP();		
112
113
114
115
116
117
118
	}
}

static void USB_Device_SetAddress(void)
{
	uint8_t wValue_LSB = Endpoint_Read_Byte();

119
	Endpoint_ClearSETUP();
120
	
121
	while (!(Endpoint_IsINReady()));
122
	
123
	Endpoint_ClearIN();
124
	
125
	while (!(Endpoint_IsINReady()));
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

	UDADDR = ((1 << ADDEN) | (wValue_LSB & 0x7F));

	return;
}

static void USB_Device_SetConfiguration(void)
{
	uint8_t wValue_LSB        = Endpoint_Read_Byte();
	bool    AlreadyConfigured = (USB_ConfigurationNumber != 0);

#if defined(USE_SINGLE_DEVICE_CONFIGURATION)
	if (wValue_LSB > 1)
#else
	USB_Descriptor_Device_t* DevDescriptorPtr;

	if ((USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr) == NO_DESCRIPTOR) ||
	#if defined(USE_RAM_DESCRIPTORS)
	    (wValue_LSB > DevDescriptorPtr->NumberOfConfigurations))
	#elif defined (USE_EEPROM_DESCRIPTORS)
	    (wValue_LSB > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
	#else
	    (wValue_LSB > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
	#endif
#endif
	{
		return;
	}
	
155
	Endpoint_ClearSETUP();
156
157
158

	USB_ConfigurationNumber = wValue_LSB;

159
	Endpoint_ClearIN();
160
161
162
163
164
165
166
167
168

	if (!(AlreadyConfigured) && USB_ConfigurationNumber)
	  RAISE_EVENT(USB_DeviceEnumerationComplete);

	RAISE_EVENT(USB_ConfigurationChanged);
}

void USB_Device_GetConfiguration(void)
{
169
	Endpoint_ClearSETUP();	
170
171
172

	Endpoint_Write_Byte(USB_ConfigurationNumber);
	
173
	Endpoint_ClearIN();
174

175
	while (!(Endpoint_IsOUTReceived()));
176
	Endpoint_ClearOUT();
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
}

static void USB_Device_GetDescriptor(void)
{
	uint16_t wValue  = Endpoint_Read_Word_LE();
	uint16_t wIndex  = Endpoint_Read_Word_LE();
	uint16_t wLength = Endpoint_Read_Word_LE();
	
	void*    DescriptorPointer;
	uint16_t DescriptorSize;
	
	bool     SendZLP;
	
	if ((DescriptorSize = USB_GetDescriptor(wValue, wIndex, &DescriptorPointer)) == NO_DESCRIPTOR)
	  return;
	
193
	Endpoint_ClearSETUP();	
194
195
196
197
198
199
	
	if (wLength > DescriptorSize)
	  wLength = DescriptorSize;
	
	while (wLength)
	{
200
		while (!(Endpoint_IsINReady()))
201
		{
202
			if (Endpoint_IsOUTReceived())
203
			{
204
				Endpoint_ClearOUT();
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
				return;
			}		
		}
		
		while (wLength && (Endpoint_BytesInEndpoint() < USB_ControlEndpointSize))
		{
			#if defined(USE_RAM_DESCRIPTORS)
			Endpoint_Write_Byte(*((uint8_t*)DescriptorPointer++));
			#elif defined (USE_EEPROM_DESCRIPTORS)
			Endpoint_Write_Byte(eeprom_read_byte(DescriptorPointer++));			
			#else
			Endpoint_Write_Byte(pgm_read_byte(DescriptorPointer++));
			#endif
			
			wLength--;
		}
		
		SendZLP = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);
223
		Endpoint_ClearIN();
224
225
226
227
	}
	
	if (SendZLP)
	{
228
		while (!(Endpoint_IsINReady()));
229
		Endpoint_ClearIN();
230
231
	}

232
	while (!(Endpoint_IsOUTReceived()));
233
	Endpoint_ClearOUT();
234
235
236
237
238
239
240
241
}

static void USB_Device_GetStatus(const uint8_t bmRequestType)
{
	uint8_t CurrentStatus = 0;

	Endpoint_Discard_Word();

242
#if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)
243
	uint8_t wIndex_LSB = Endpoint_Read_Byte();
244
#endif
245
246
247
248
249
250
251
252
253
254
255
	
	switch (bmRequestType)
	{
		case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
			if (USB_CurrentlySelfPowered)
			  CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
			
			if (USB_RemoteWakeupEnabled)
			  CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
			
			break;
256
#if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)
257
258
259
260
261
262
		case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
			Endpoint_SelectEndpoint(wIndex_LSB);

			CurrentStatus = Endpoint_IsStalled();

			break;
263
#endif
264
265
266
	}
	
	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);			  
267
	Endpoint_ClearSETUP();
268

269
270
	Endpoint_Write_Word_LE(CurrentStatus);

271
	Endpoint_ClearIN();
272
	
273
	while (!(Endpoint_IsOUTReceived()));
274
	Endpoint_ClearOUT();
275
276
}

277
#if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
static void USB_Device_ClearSetFeature(const uint8_t bRequest, const uint8_t bmRequestType)
{
	uint16_t wValue = Endpoint_Read_Word_LE();
	uint16_t wIndex = Endpoint_Read_Word_LE();
	
	switch (bmRequestType & CONTROL_REQTYPE_RECIPIENT)
	{
		case REQREC_ENDPOINT:
			if (wValue == FEATURE_ENDPOINT_HALT)
			{
				uint8_t EndpointIndex = (wIndex & ENDPOINT_EPNUM_MASK);
				
				if (EndpointIndex != ENDPOINT_CONTROLEP)
				{
					Endpoint_SelectEndpoint(EndpointIndex);

					if (Endpoint_IsEnabled())
					{				
						if (bRequest == REQ_ClearFeature)
						{
							Endpoint_ClearStall();
							Endpoint_ResetFIFO(EndpointIndex);
							Endpoint_ResetDataToggle();
						}
						else
						{
							Endpoint_StallTransaction();						
						}
					}

					Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
309
310
					Endpoint_ClearSETUP();
					Endpoint_ClearIN();
311
312
313
314
315
316
317
318
319
				}
			}
			
			break;
	}
}
#endif

#endif