changed tabs to spaces in bluefruit.c
[tmk_keyboard.git] / protocol / ps2.c
1 /*
2 Copyright 2010,2011 Jun WAKO <wakojun@gmail.com>
3
4 This software is licensed with a Modified BSD License.
5 All of this is supposed to be Free Software, Open Source, DFSG-free,
6 GPL-compatible, and OK to use in both free and proprietary applications.
7 Additions and corrections to this file are welcome.
8
9
10 Redistribution and use in source and binary forms, with or without
11 modification, are permitted provided that the following conditions are met:
12
13 * Redistributions of source code must retain the above copyright
14 notice, this list of conditions and the following disclaimer.
15
16 * Redistributions in binary form must reproduce the above copyright
17 notice, this list of conditions and the following disclaimer in
18 the documentation and/or other materials provided with the
19 distribution.
20
21 * Neither the name of the copyright holders nor the names of
22 contributors may be used to endorse or promote products derived
23 from this software without specific prior written permission.
24
25 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
29 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 POSSIBILITY OF SUCH DAMAGE.
36 */
37
38 #include <stdbool.h>
39 #include <avr/io.h>
40 #include <avr/interrupt.h>
41 #include <util/delay.h>
42 #include "ps2.h"
43 #include "debug.h"
44
45
46 static uint8_t recv_data(void);
47 static inline void clock_lo(void);
48 static inline void clock_hi(void);
49 static inline bool clock_in(void);
50 static inline void data_lo(void);
51 static inline void data_hi(void);
52 static inline bool data_in(void);
53 static inline uint16_t wait_clock_lo(uint16_t us);
54 static inline uint16_t wait_clock_hi(uint16_t us);
55 static inline uint16_t wait_data_lo(uint16_t us);
56 static inline uint16_t wait_data_hi(uint16_t us);
57 static inline void idle(void);
58 static inline void inhibit(void);
59
60
61 /*
62 Primitive PS/2 Library for AVR
63 ==============================
64 Host side is only supported now.
65
66
67 I/O control
68 -----------
69 High state is asserted by input with pull up.
70
71
72 PS/2 References
73 ---------------
74 http://www.computer-engineering.org/ps2protocol/
75 http://www.mcamafia.de/pdf/ibm_hitrc07.pdf
76 */
77
78
79 #define WAIT(stat, us, err) do { \
80 if (!wait_##stat(us)) { \
81 ps2_error = err; \
82 goto ERROR; \
83 } \
84 } while (0)
85
86
87 uint8_t ps2_error = PS2_ERR_NONE;
88
89
90 void ps2_host_init(void)
91 {
92 #ifdef PS2_USE_INT
93 PS2_INT_INIT();
94 PS2_INT_ON();
95 idle();
96 #else
97 inhibit();
98 #endif
99 }
100
101 // TODO: send using interrupt if available
102 uint8_t ps2_host_send(uint8_t data)
103 {
104 uint8_t res = 0;
105 bool parity = true;
106 ps2_error = PS2_ERR_NONE;
107 #ifdef PS2_USE_INT
108 PS2_INT_OFF();
109 #endif
110 /* terminate a transmission if we have */
111 inhibit();
112 _delay_us(100);
113
114 /* start bit [1] */
115 data_lo();
116 clock_hi();
117 WAIT(clock_lo, 15000, 1);
118 /* data [2-9] */
119 for (uint8_t i = 0; i < 8; i++) {
120 _delay_us(15);
121 if (data&(1<<i)) {
122 parity = !parity;
123 data_hi();
124 } else {
125 data_lo();
126 }
127 WAIT(clock_hi, 50, 2);
128 WAIT(clock_lo, 50, 3);
129 }
130 /* parity [10] */
131 _delay_us(15);
132 if (parity) { data_hi(); } else { data_lo(); }
133 WAIT(clock_hi, 50, 4);
134 WAIT(clock_lo, 50, 5);
135 /* stop bit [11] */
136 _delay_us(15);
137 data_hi();
138 /* ack [12] */
139 WAIT(data_lo, 50, 6);
140 WAIT(clock_lo, 50, 7);
141
142 /* wait for idle state */
143 WAIT(clock_hi, 50, 8);
144 WAIT(data_hi, 50, 9);
145
146 res = ps2_host_recv_response();
147 ERROR:
148 #ifdef PS2_USE_INT
149 PS2_INT_ON();
150 idle();
151 #else
152 inhibit();
153 #endif
154 return res;
155 }
156
157 /* receive data when host want else inhibit communication */
158 uint8_t ps2_host_recv_response(void)
159 {
160 uint8_t data = 0;
161
162 /* terminate a transmission if we have */
163 inhibit();
164 _delay_us(100);
165
166 /* release lines(idle state) */
167 idle();
168
169 /* wait start bit */
170 wait_clock_lo(2000);
171 data = recv_data();
172
173 inhibit();
174 return data;
175 }
176
177 #ifndef PS2_USE_INT
178 uint8_t ps2_host_recv(void)
179 {
180 return ps2_host_recv_response();
181 }
182 #else
183 /* ring buffer to store ps/2 key data */
184 #define PBUF_SIZE 32
185 static uint8_t pbuf[PBUF_SIZE];
186 static uint8_t pbuf_head = 0;
187 static uint8_t pbuf_tail = 0;
188 static inline void pbuf_enqueue(uint8_t data)
189 {
190 if (!data)
191 return;
192
193 uint8_t sreg = SREG;
194 cli();
195 uint8_t next = (pbuf_head + 1) % PBUF_SIZE;
196 if (next != pbuf_tail) {
197 pbuf[pbuf_head] = data;
198 pbuf_head = next;
199 } else {
200 debug("pbuf: full\n");
201 }
202 SREG = sreg;
203 }
204 static inline uint8_t pbuf_dequeue(void)
205 {
206 uint8_t val = 0;
207
208 uint8_t sreg = SREG;
209 cli();
210 if (pbuf_head != pbuf_tail) {
211 val = pbuf[pbuf_tail];
212 pbuf_tail = (pbuf_tail + 1) % PBUF_SIZE;
213 }
214 SREG = sreg;
215
216 return val;
217 }
218
219 /* get data received by interrupt */
220 uint8_t ps2_host_recv(void)
221 {
222 if (ps2_error) {
223 print("x");
224 phex(ps2_error);
225 ps2_host_send(0xFE); // request to resend
226 ps2_error = PS2_ERR_NONE;
227 }
228 idle();
229 return pbuf_dequeue();
230 }
231
232 #if 0
233 #define DEBUGP_INIT() do { DDRC = 0xFF; } while (0)
234 #define DEBUGP(x) do { PORTC = x; } while (0)
235 #else
236 #define DEBUGP_INIT()
237 #define DEBUGP(x)
238 #endif
239 ISR(PS2_INT_VECT)
240 {
241 static enum {
242 INIT,
243 START,
244 BIT0, BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7,
245 PARITY,
246 STOP,
247 } state = INIT;
248 static uint8_t data = 0;
249 static uint8_t parity = 1;
250
251 // TODO: abort if elapse 100us from previous interrupt
252
253 // return unless falling edge
254 if (clock_in()) {
255 goto RETURN;
256 }
257
258 state++;
259 DEBUGP(state);
260 switch (state) {
261 case START:
262 if (data_in())
263 goto ERROR;
264 break;
265 case BIT0:
266 case BIT1:
267 case BIT2:
268 case BIT3:
269 case BIT4:
270 case BIT5:
271 case BIT6:
272 case BIT7:
273 data >>= 1;
274 if (data_in()) {
275 data |= 0x80;
276 parity++;
277 }
278 break;
279 case PARITY:
280 if (data_in()) {
281 if (!(parity & 0x01))
282 goto ERROR;
283 } else {
284 if (parity & 0x01)
285 goto ERROR;
286 }
287 break;
288 case STOP:
289 if (!data_in())
290 goto ERROR;
291 pbuf_enqueue(data);
292 goto DONE;
293 break;
294 default:
295 goto ERROR;
296 }
297 goto RETURN;
298 ERROR:
299 DEBUGP(0x0F);
300 inhibit();
301 ps2_error = state;
302 DONE:
303 state = INIT;
304 data = 0;
305 parity = 1;
306 RETURN:
307 return;
308 }
309 #endif
310
311
312 static void ps2_reset(void)
313 {
314 ps2_host_send(0xFF);
315 }
316
317 /* send LED state to keyboard */
318 void ps2_host_set_led(uint8_t led)
319 {
320 ps2_host_send(0xED);
321 ps2_host_send(led);
322 }
323
324
325 /* called after start bit comes */
326 static uint8_t recv_data(void)
327 {
328 uint8_t data = 0;
329 bool parity = true;
330 ps2_error = PS2_ERR_NONE;
331
332 /* start bit [1] */
333 WAIT(clock_lo, 1, 1);
334 WAIT(data_lo, 1, 2);
335 WAIT(clock_hi, 50, 3);
336
337 /* data [2-9] */
338 for (uint8_t i = 0; i < 8; i++) {
339 WAIT(clock_lo, 50, 4);
340 if (data_in()) {
341 parity = !parity;
342 data |= (1<<i);
343 }
344 WAIT(clock_hi, 50, 5);
345 }
346
347 /* parity [10] */
348 WAIT(clock_lo, 50, 6);
349 if (data_in() != parity) {
350 ps2_error = PS2_ERR_PARITY;
351 goto ERROR;
352 }
353 WAIT(clock_hi, 50, 7);
354
355 /* stop bit [11] */
356 WAIT(clock_lo, 50, 8);
357 WAIT(data_hi, 1, 9);
358 WAIT(clock_hi, 50, 10);
359
360 return data;
361 ERROR:
362 return 0;
363 }
364
365 static inline void clock_lo()
366 {
367 PS2_CLOCK_PORT &= ~(1<<PS2_CLOCK_BIT);
368 PS2_CLOCK_DDR |= (1<<PS2_CLOCK_BIT);
369 }
370 static inline void clock_hi()
371 {
372 /* input with pull up */
373 PS2_CLOCK_DDR &= ~(1<<PS2_CLOCK_BIT);
374 PS2_CLOCK_PORT |= (1<<PS2_CLOCK_BIT);
375 }
376 static inline bool clock_in()
377 {
378 PS2_CLOCK_DDR &= ~(1<<PS2_CLOCK_BIT);
379 PS2_CLOCK_PORT |= (1<<PS2_CLOCK_BIT);
380 _delay_us(1);
381 return PS2_CLOCK_PIN&(1<<PS2_CLOCK_BIT);
382 }
383 static inline void data_lo()
384 {
385 PS2_DATA_PORT &= ~(1<<PS2_DATA_BIT);
386 PS2_DATA_DDR |= (1<<PS2_DATA_BIT);
387 }
388 static inline void data_hi()
389 {
390 /* input with pull up */
391 PS2_DATA_DDR &= ~(1<<PS2_DATA_BIT);
392 PS2_DATA_PORT |= (1<<PS2_DATA_BIT);
393 }
394 static inline bool data_in()
395 {
396 PS2_DATA_DDR &= ~(1<<PS2_DATA_BIT);
397 PS2_DATA_PORT |= (1<<PS2_DATA_BIT);
398 _delay_us(1);
399 return PS2_DATA_PIN&(1<<PS2_DATA_BIT);
400 }
401
402 static inline uint16_t wait_clock_lo(uint16_t us)
403 {
404 while (clock_in() && us) { asm(""); _delay_us(1); us--; }
405 return us;
406 }
407 static inline uint16_t wait_clock_hi(uint16_t us)
408 {
409 while (!clock_in() && us) { asm(""); _delay_us(1); us--; }
410 return us;
411 }
412 static inline uint16_t wait_data_lo(uint16_t us)
413 {
414 while (data_in() && us) { asm(""); _delay_us(1); us--; }
415 return us;
416 }
417 static inline uint16_t wait_data_hi(uint16_t us)
418 {
419 while (!data_in() && us) { asm(""); _delay_us(1); us--; }
420 return us;
421 }
422
423 /* idle state that device can send */
424 static inline void idle(void)
425 {
426 clock_hi();
427 data_hi();
428 }
429
430 /* inhibit device to send */
431 static inline void inhibit(void)
432 {
433 clock_lo();
434 data_hi();
435 }
Imprint / Impressum