ATY_LIB V2_102_230218
ATY_LIB for general devices or ALGO
 
Loading...
Searching...
No Matches
Functions | Variables
usb_hid.c File Reference
#include "fw_hal.h"
#include <string.h>

Go to the source code of this file.

Functions

void USB_Init ()
 
uint8_t CalCheckSum (uint8_t *buf, uint8_t len)
 
void main ()
 
 INTERRUPT (USB_Routine, EXTI_VectUSB)
 

Variables

__CODE uint8_t DEVICEDESC [18]
 
__CODE uint8_t CONFIGDESC [41]
 
__CODE uint8_t HIDREPORTDESC [27]
 
__CODE uint8_t LANGIDDESC [4]
 
__CODE uint8_t MANUFACTDESC [8]
 
__CODE uint8_t PRODUCTDESC [30]
 
__XDATA uint8_t HidFreature [64]
 
__XDATA uint8_t HidInput [64]
 
__XDATA uint8_t HidOutput [64]
 
USB_Request_t usb_request
 
USB_EP0_Stage_t usb_ep0_stag
 

Function Documentation

◆ CalCheckSum()

uint8_t CalCheckSum ( uint8_t *  buf,
uint8_t  len 
)

Definition at line 446 of file usb_hid.c.

447{
448 uint8_t i;
449 uint8_t cs=0;
450 for (i = 0; i < len; i++)
451 {
452 cs += buf[i];
453 }
454 return cs;
455}
uint8_t
unsigned char uint8_t
Definition: fw_types.h:18
i
uint8_t __XDATA i
Definition: mem_read_chipid.c:24

◆ INTERRUPT()

INTERRUPT ( USB_Routine  ,
EXTI_VectUSB   
)

Reset Interrupt

Endpoint-0 Interrupt

Endpoint-1 In Interrupt

Endpoint-1 Out Interrupt

Write response

Definition at line 71 of file usb_hid.c.

72{
73 uint8_t intrusb;
74 uint8_t intrin;
75 uint8_t introut;
76 uint8_t csr;
77 uint8_t cnt;
78 uint16_t len = 0;
79 intrusb = USB_ReadReg(INTRUSB);
80 intrin = USB_ReadReg(INTRIN1);
81 introut = USB_ReadReg(INTROUT1);
82
86 if (intrusb & RSTIF)
87 {
88 USB_SelectEndPoint(1);
89 USB_WriteReg(INCSR1, INCLRDT);
90 USB_SelectEndPoint(1);
91 USB_WriteReg(OUTCSR1, OUTCLRDT);
92 usb_ep0_stag.bStage = USB_CtrlState_Idle;
93 }
94
98 if (intrin & EP0IF)
99 {
100 USB_SelectEndPoint(0);
101 csr = USB_ReadReg(CSR0);
102 if (csr & STSTL) // Sent Stall
103 {
104 USB_WriteReg(CSR0, csr & ~STSTL);
105 usb_ep0_stag.bStage = USB_CtrlState_Idle;
106 }
107
108 if (csr & SUEND) // Setup End
109 {
110 USB_WriteReg(CSR0, csr | SSUEND);
111 }
112
113 switch (usb_ep0_stag.bStage)
114 {
115 case USB_CtrlState_Idle:
116 if (csr & OPRDY) // Out Packet Ready
117 {
118 usb_ep0_stag.bStage = USB_CtrlState_SettingUp;
119 USB_ReadFIFO(FIFO0, (uint8_t *)&usb_request);
120 ((uint8_t *)&usb_ep0_stag.wResidue)[0] = usb_request.wLength.bb.bh;
121 ((uint8_t *)&usb_ep0_stag.wResidue)[1] = usb_request.wLength.bb.bl;
122 switch (usb_request.bmRequestType & REQUEST_TYPE_MASK)
123 {
124 case USB_RequestType_Standard:
125 switch (usb_request.bRequest)
126 {
127 case USB_StdReq_SetAddress:
128 USB_WriteReg(FADDR, usb_request.wValue.bb.bl);
129 break;
130
131 case USB_StdReq_SetConfiguration:
132 USB_SelectEndPoint(1);
133 USB_WriteReg(INCSR2, INMODEIN);
134 USB_WriteReg(INMAXP, 8);
135 USB_SelectEndPoint(1);
136 USB_WriteReg(INCSR2, INMODEOUT);
137 USB_WriteReg(OUTMAXP, 8);
138 USB_SelectEndPoint(0);
139 break;
140
141 case USB_StdReq_GetDescriptor:
142 usb_ep0_stag.bStage = USB_CtrlState_DataIn;
143 switch (usb_request.wValue.bb.bh)
144 {
145 case USB_DescriptorType_Device:
146 usb_ep0_stag.pData = (uint8_t *)DEVICEDESC;
147 len = sizeof(DEVICEDESC);
148 break;
149
150 case USB_DescriptorType_Configuration:
151 usb_ep0_stag.pData = (uint8_t *)CONFIGDESC;
152 len = sizeof(CONFIGDESC);
153 break;
154
155 case USB_DescriptorType_String:
156 switch (usb_request.wValue.bb.bl)
157 {
158 case 0:
159 usb_ep0_stag.pData = (uint8_t *)LANGIDDESC;
160 len = sizeof(LANGIDDESC);
161 break;
162
163 case 1:
164 usb_ep0_stag.pData = (uint8_t *)MANUFACTDESC;
165 len = sizeof(MANUFACTDESC);
166 break;
167
168 case 2:
169 usb_ep0_stag.pData = (uint8_t *)PRODUCTDESC;
170 len = sizeof(PRODUCTDESC);
171 break;
172
173 default:
174 usb_ep0_stag.bStage = USB_CtrlState_Stalled;
175 break;
176 }
177 break;
178
179 case USB_DescriptorType_Report:
180 usb_ep0_stag.pData = (uint8_t *)HIDREPORTDESC;
181 len = sizeof(HIDREPORTDESC);
182 break;
183
184 default:
185 usb_ep0_stag.bStage = USB_CtrlState_Stalled;
186 break;
187 }
188 if (len < usb_ep0_stag.wResidue)
189 {
190 usb_ep0_stag.wResidue = len;
191 }
192 break;
193
194 default:
195 usb_ep0_stag.bStage = USB_CtrlState_Stalled;
196 break;
197 }
198 break;
199
200 case USB_RequestType_Class:
201 switch (usb_request.bRequest)
202 {
203 case USB_HidReq_GetReport:
204 usb_ep0_stag.pData = HidFreature;
205 usb_ep0_stag.bStage = USB_CtrlState_DataIn;
206 break;
207
208 case USB_HidReq_SetReport:
209 usb_ep0_stag.pData = HidFreature;
210 usb_ep0_stag.bStage = USB_CtrlState_DataOut;
211 break;
212
213 case USB_HidReq_SetIdle:
214 break;
215
216 // case USB_HidReq_GetIdle:
217 // case USB_HidReq_GetProtocol:
218 // case USB_HidReq_SetProtocol:
219 default:
220 usb_ep0_stag.bStage = USB_CtrlState_Stalled;
221 break;
222 }
223 break;
224
225 default:
226 usb_ep0_stag.bStage = USB_CtrlState_Stalled;
227 break;
228 }
229
230 switch (usb_ep0_stag.bStage)
231 {
232 case USB_CtrlState_DataIn:
233 USB_WriteReg(CSR0, SOPRDY);
234 goto L_Ep0SendData;
235 break;
236
237 case USB_CtrlState_DataOut:
238 USB_WriteReg(CSR0, SOPRDY);
239 break;
240
241 case USB_CtrlState_SettingUp:
242 USB_WriteReg(CSR0, SOPRDY | DATEND);
243 usb_ep0_stag.bStage = USB_CtrlState_Idle;
244 break;
245
246 case USB_CtrlState_Stalled:
247 USB_WriteReg(CSR0, SOPRDY | SDSTL);
248 usb_ep0_stag.bStage = USB_CtrlState_Idle;
249 break;
250 }
251 }
252 break;
253
254 case USB_CtrlState_DataIn:
255 if (!(csr & IPRDY))
256 {
257 L_Ep0SendData:
258 cnt = usb_ep0_stag.wResidue > 64 ? 64 : usb_ep0_stag.wResidue;
259 USB_WriteFIFO(FIFO0, usb_ep0_stag.pData, cnt);
260 usb_ep0_stag.wResidue -= cnt;
261 usb_ep0_stag.pData += cnt;
262 if (usb_ep0_stag.wResidue == 0)
263 {
264 USB_WriteReg(CSR0, IPRDY | DATEND);
265 usb_ep0_stag.bStage = USB_CtrlState_Idle;
266 }
267 else
268 {
269 USB_WriteReg(CSR0, IPRDY);
270 }
271 }
272 break;
273
274 case USB_CtrlState_DataOut:
275 if (csr & OPRDY)
276 {
277 cnt = USB_ReadFIFO(FIFO0, usb_ep0_stag.pData);
278 usb_ep0_stag.wResidue -= cnt;
279 usb_ep0_stag.pData += cnt;
280 if (usb_ep0_stag.wResidue == 0)
281 {
282 USB_WriteReg(CSR0, SOPRDY | DATEND);
283 usb_ep0_stag.bStage = USB_CtrlState_Idle;
284 }
285 else
286 {
287 USB_WriteReg(CSR0, SOPRDY);
288 }
289 }
290 break;
291 }
292 }
293
297 if (intrin & EP1INIF)
298 {
299 USB_SelectEndPoint(1);
300 csr = USB_ReadReg(INCSR1);
301 if (csr & INSTSTL)
302 {
303 USB_WriteReg(INCSR1, INCLRDT);
304 }
305 if (csr & INUNDRUN)
306 {
307 USB_WriteReg(INCSR1, 0);
308 }
309 }
310
314 if (introut & EP1OUTIF)
315 {
316 USB_SelectEndPoint(1);
317 csr = USB_ReadReg(OUTCSR1);
318 if (csr & OUTSTSTL)
319 {
320 USB_WriteReg(OUTCSR1, OUTCLRDT);
321 }
322 if (csr & OUTOPRDY)
323 {
324 USB_ReadFIFO(FIFO1, HidInput);
325 USB_WriteReg(OUTCSR1, 0);
327 if((HidInput[0] == 0xaa) && (HidInput[1] == 0x55) && (HidInput[2] == 0x01))
328 {
329 USB_SelectEndPoint(1);
330 USB_WriteFIFO(FIFO1, HidOutput, 64);
331 USB_WriteReg(INCSR1, INIPRDY);
332 }
333 }
334 }
335}
uint16_t
unsigned short uint16_t
Definition: fw_types.h:19
SDSTL
#define SDSTL
Definition: fw_usb.h:70
USB_HidReq_SetIdle
@ USB_HidReq_SetIdle
Definition: fw_usb.h:148
USB_HidReq_SetReport
@ USB_HidReq_SetReport
Definition: fw_usb.h:147
USB_HidReq_GetReport
@ USB_HidReq_GetReport
Definition: fw_usb.h:144
OUTMAXP
#define OUTMAXP
Definition: fw_usb.h:91
CSR0
#define CSR0
Definition: fw_usb.h:67
INCLRDT
#define INCLRDT
Definition: fw_usb.h:77
EP1OUTIF
#define EP1OUTIF
Definition: fw_usb.h:39
INTRUSB
#define INTRUSB
Definition: fw_usb.h:40
OUTCSR1
#define OUTCSR1
Definition: fw_usb.h:92
EP0IF
#define EP0IF
Definition: fw_usb.h:33
INUNDRUN
#define INUNDRUN
Definition: fw_usb.h:81
INCSR1
#define INCSR1
Definition: fw_usb.h:76
INMODEOUT
#define INMODEOUT
Definition: fw_usb.h:88
USB_SelectEndPoint
#define USB_SelectEndPoint(__INDEX__)
Definition: fw_usb.h:230
USB_WriteReg
void USB_WriteReg(uint8_t addr, uint8_t dat)
INSTSTL
#define INSTSTL
Definition: fw_usb.h:78
INTROUT1
#define INTROUT1
Definition: fw_usb.h:34
EP1INIF
#define EP1INIF
Definition: fw_usb.h:32
USB_ReadReg
uint8_t USB_ReadReg(uint8_t addr)
OUTOPRDY
#define OUTOPRDY
Definition: fw_usb.h:100
SSUEND
#define SSUEND
Definition: fw_usb.h:68
USB_WriteFIFO
void USB_WriteFIFO(uint8_t fifo, uint8_t *pdat, uint8_t cnt)
USB_RequestType_Standard
@ USB_RequestType_Standard
Definition: fw_usb.h:168
USB_RequestType_Class
@ USB_RequestType_Class
Definition: fw_usb.h:169
INCSR2
#define INCSR2
Definition: fw_usb.h:84
USB_ReadFIFO
uint8_t USB_ReadFIFO(uint8_t fifo, uint8_t *pdat)
FADDR
#define FADDR
Definition: fw_usb.h:25
INTRIN1
#define INTRIN1
Definition: fw_usb.h:27
USB_CtrlState_DataIn
@ USB_CtrlState_DataIn
Definition: fw_usb.h:122
USB_CtrlState_Stalled
@ USB_CtrlState_Stalled
Definition: fw_usb.h:124
USB_CtrlState_Idle
@ USB_CtrlState_Idle
Definition: fw_usb.h:120
USB_CtrlState_DataOut
@ USB_CtrlState_DataOut
Definition: fw_usb.h:123
USB_CtrlState_SettingUp
@ USB_CtrlState_SettingUp
Definition: fw_usb.h:121
FIFO0
#define FIFO0
Definition: fw_usb.h:109
OUTCLRDT
#define OUTCLRDT
Definition: fw_usb.h:93
IPRDY
#define IPRDY
Definition: fw_usb.h:74
INIPRDY
#define INIPRDY
Definition: fw_usb.h:83
USB_DescriptorType_String
@ USB_DescriptorType_String
Definition: fw_usb.h:156
USB_DescriptorType_Report
@ USB_DescriptorType_Report
Definition: fw_usb.h:160
USB_DescriptorType_Device
@ USB_DescriptorType_Device
Definition: fw_usb.h:154
USB_DescriptorType_Configuration
@ USB_DescriptorType_Configuration
Definition: fw_usb.h:155
RSTIF
#define RSTIF
Definition: fw_usb.h:42
FIFO1
#define FIFO1
Definition: fw_usb.h:110
USB_StdReq_GetDescriptor
@ USB_StdReq_GetDescriptor
Definition: fw_usb.h:133
USB_StdReq_SetConfiguration
@ USB_StdReq_SetConfiguration
Definition: fw_usb.h:136
USB_StdReq_SetAddress
@ USB_StdReq_SetAddress
Definition: fw_usb.h:132
INMAXP
#define INMAXP
Definition: fw_usb.h:66
DATEND
#define DATEND
Definition: fw_usb.h:72
STSTL
#define STSTL
Definition: fw_usb.h:73
REQUEST_TYPE_MASK
#define REQUEST_TYPE_MASK
Definition: fw_usb.h:164
SOPRDY
#define SOPRDY
Definition: fw_usb.h:69
SUEND
#define SUEND
Definition: fw_usb.h:71
OUTSTSTL
#define OUTSTSTL
Definition: fw_usb.h:94
INMODEIN
#define INMODEIN
Definition: fw_usb.h:87
OPRDY
#define OPRDY
Definition: fw_usb.h:75
USB_EP0_Stage_t::wResidue
uint16_t wResidue
Definition: fw_usb.h:255
USB_EP0_Stage_t::bStage
uint8_t bStage
Definition: fw_usb.h:254
USB_EP0_Stage_t::pData
uint8_t * pData
Definition: fw_usb.h:256
USB_Request_t::wLength
uint16_2uint8_t wLength
Definition: fw_usb.h:249
USB_Request_t::bmRequestType
uint8_t bmRequestType
Definition: fw_usb.h:245
USB_Request_t::bRequest
uint8_t bRequest
Definition: fw_usb.h:246
USB_Request_t::wValue
uint16_2uint8_t wValue
Definition: fw_usb.h:247
uint16_2uint8_t::_bb::bl
uint8_t bl
Definition: fw_usb.h:238
uint16_2uint8_t::_bb::bh
uint8_t bh
Definition: fw_usb.h:239
uint16_2uint8_t::bb
struct uint16_2uint8_t::_bb bb
HidFreature
__XDATA uint8_t HidFreature[64]
Definition: usb_hid.c:24
HidInput
__XDATA uint8_t HidInput[64]
Definition: usb_hid.c:25
DEVICEDESC
__CODE uint8_t DEVICEDESC[18]
Definition: usb_hid.c:18
MANUFACTDESC
__CODE uint8_t MANUFACTDESC[8]
Definition: usb_hid.c:22
HidOutput
__XDATA uint8_t HidOutput[64]
Definition: usb_hid.c:26
usb_ep0_stag
USB_EP0_Stage_t usb_ep0_stag
Definition: usb_hid.c:28
usb_request
USB_Request_t usb_request
Definition: usb_hid.c:27
HIDREPORTDESC
__CODE uint8_t HIDREPORTDESC[27]
Definition: usb_hid.c:20
PRODUCTDESC
__CODE uint8_t PRODUCTDESC[30]
Definition: usb_hid.c:23
CONFIGDESC
__CODE uint8_t CONFIGDESC[41]
Definition: usb_hid.c:19
LANGIDDESC
__CODE uint8_t LANGIDDESC[4]
Definition: usb_hid.c:21

◆ main()

void main ( void  )

Definition at line 33 of file usb_hid.c.

34{
35 GPIO_P3_SetMode(GPIO_Pin_0|GPIO_Pin_1, GPIO_Mode_Input_HIP);
36 USB_Init();
37 EXTI_Global_SetIntState(HAL_State_ON);
38
39 memset(HidOutput, 0x00, sizeof(HidOutput));
40 HidOutput[0] = 0xaa;
41 HidOutput[1] = 0x55;
42 HidOutput[2] = 0x02;
43 HidOutput[3] = 0x01;
44 HidOutput[4] = 0x02;
45 HidOutput[5] = 0x01;
46 HidOutput[6] = 0x02;
47 HidOutput[7] = CalCheckSum(HidOutput,7);
48
49 while (1);
50}
EXTI_Global_SetIntState
#define EXTI_Global_SetIntState(__STATE__)
Definition: fw_exti.h:115
GPIO_P3_SetMode
#define GPIO_P3_SetMode(__PINS__, __MODE__)
Definition: fw_gpio.h:89
GPIO_Pin_0
@ GPIO_Pin_0
Definition: fw_gpio.h:45
GPIO_Pin_1
@ GPIO_Pin_1
Definition: fw_gpio.h:46
GPIO_Mode_Input_HIP
@ GPIO_Mode_Input_HIP
Definition: fw_gpio.h:25
HAL_State_ON
@ HAL_State_ON
Definition: fw_types.h:71
CalCheckSum
uint8_t CalCheckSum(uint8_t *buf, uint8_t len)
Definition: usb_hid.c:446
USB_Init
void USB_Init()
Definition: usb_hid.c:52

◆ USB_Init()

void USB_Init ( void  )

Definition at line 52 of file usb_hid.c.

53{
54 SYS_EnableOscillator48M();
55 USB_SetClockSource(USB_ClockSource_6M);
56 USB_SetEnabled(HAL_State_ON);
57 USB_SetDpDmPullUp(HAL_State_ON);
58 EXTI_USB_SetIntPriority(EXTI_IntPriority_Highest);
59
60 USB_WriteReg(FADDR, 0x00);
61 USB_WriteReg(POWER, 0x08);
62 USB_WriteReg(INTRIN1E, 0x3f);
63 USB_WriteReg(INTROUT1E, 0x3f);
64 USB_WriteReg(INTRUSBE, 0x00);
65 USB_WriteReg(POWER, 0x01);
66 usb_ep0_stag.bStage = USB_CtrlState_Idle;
67
68 EXTI_USB_SetIntState(HAL_State_ON);
69}
EXTI_USB_SetIntPriority
#define EXTI_USB_SetIntPriority(__PRIORITY__)
Definition: fw_exti.h:228
EXTI_IntPriority_Highest
@ EXTI_IntPriority_Highest
Definition: fw_exti.h:26
EXTI_USB_SetIntState
#define EXTI_USB_SetIntState(__STATE__)
Definition: fw_exti.h:129
SYS_EnableOscillator48M
#define SYS_EnableOscillator48M()
Definition: fw_sys.h:153
INTROUT1E
#define INTROUT1E
Definition: fw_usb.h:52
POWER
#define POWER
Definition: fw_usb.h:26
INTRIN1E
#define INTRIN1E
Definition: fw_usb.h:45
INTRUSBE
#define INTRUSBE
Definition: fw_usb.h:58
USB_ClockSource_6M
@ USB_ClockSource_6M
Definition: fw_usb.h:175
USB_SetClockSource
#define USB_SetClockSource(__SOURCE__)
Definition: fw_usb.h:190
USB_SetEnabled
#define USB_SetEnabled(__STATE__)
Definition: fw_usb.h:196
USB_SetDpDmPullUp
#define USB_SetDpDmPullUp(__STATE__)
Definition: fw_usb.h:203

Variable Documentation

◆ CONFIGDESC

__CODE uint8_t CONFIGDESC

Definition at line 19 of file usb_hid.c.

◆ DEVICEDESC

__CODE uint8_t DEVICEDESC
Initial value:
=
{
0x12,
0x01,
0x00,0x02,
0x00,
0x00,
0x00,
0x40,
0x54,0x53,
0x80,0x43,
0x00,0x01,
0x01,
0x02,
0x00,
0x01,
}

Definition at line 18 of file usb_hid.c.

◆ HidFreature

__XDATA uint8_t HidFreature[64]

Definition at line 24 of file usb_hid.c.

◆ HidInput

__XDATA uint8_t HidInput[64]

Definition at line 25 of file usb_hid.c.

◆ HidOutput

__XDATA uint8_t HidOutput[64]

Definition at line 26 of file usb_hid.c.

◆ HIDREPORTDESC

__CODE uint8_t HIDREPORTDESC
Initial value:
=
{
0x05,0x0c,
0x09,0x01,
0xa1,0x01,
0x15,0x00,
0x25,0xff,
0x75,0x08,
0x95,0x40,
0x09,0x01,
0xb1,0x02,
0x09,0x01,
0x81,0x02,
0x09,0x01,
0x91,0x02,
0xc0,
}

Definition at line 20 of file usb_hid.c.

◆ LANGIDDESC

__CODE uint8_t LANGIDDESC
Initial value:
=
{
0x04,0x03,
0x09,0x04,
}

Definition at line 21 of file usb_hid.c.

◆ MANUFACTDESC

__CODE uint8_t MANUFACTDESC
Initial value:
=
{
0x08,0x03,
'S',0,
'T',0,
'C',0,
}

Definition at line 22 of file usb_hid.c.

◆ PRODUCTDESC

__CODE uint8_t PRODUCTDESC
Initial value:
=
{
0x1e,0x03,
'S',0,
'T',0,
'C',0,
'8',0,
' ',0,
'F',0,
'w',0,
'L',0,
'i',0,
'b',0,
' ',0,
'H',0,
'I',0,
'D',0,
}

Definition at line 23 of file usb_hid.c.

◆ usb_ep0_stag

USB_EP0_Stage_t usb_ep0_stag

Definition at line 28 of file usb_hid.c.

◆ usb_request

USB_Request_t usb_request

Definition at line 27 of file usb_hid.c.