-
Notifications
You must be signed in to change notification settings - Fork 20
/
TrulyErgonomic_209_v3.lst.annotated
4961 lines (4753 loc) · 240 KB
/
TrulyErgonomic_209_v3.lst.annotated
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
31
32
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
59
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
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
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
;; -*- mode: Asm; indent-tabs-mode: nil; comment-column: 48; tab-width: 4 -*-
;;
;; Data variables
;; ==============
;;
;; Ports:
;; B1 P3.1 DIP switch 4
;; B2 P3.2 DIP switch 3
;; B5 P3.5 Num Lock
;; B6 P3.6 Caps Lock
;; B7 P3.7 Scroll Lock
;; E9 P4.1 DIP switch 2
;; EA P4.2 DIP switch 1
;;
;; RAM:
;; 00 register bank 0
;; 08 register bank 1
;; 10 register bank 2
;; 18 register bank 3
;; 20 byte led_state;
;; Used in do_receive(), zeroed in init_vars()
;; Used in upd_leds() as [? ? ? ? ? Scroll Caps ?] bit mask
;; Bit 0 used in numlock_on() in connection with NumLock
;; 21 enum { KBMODE_NORMAL = 0x5A, KBMODE_MACRO = 0xA5 } kb_mode
;; Used in upd_leds(), assigned in init_vars(), used in decode_fn(), complemented in process_shift_f12()
;; // num_lock_fn_lock?
;; 22 byte shift_f12_count;
;; Zeroed in init_vars(), incremented/tested/zeroed in process_shift_f12()
;; 23 byte column_index;
;; Zeroed in init_vars(), used in scan_column(), used in same_column_value() as column index,
;; used in process_key()
;; 24 byte column_value;
;; Assigned column value in scan_column(), used in two_bits_set()
;; 25 union {
;; byte new_column_value;
;; Assigned in read_column()
;; byte old_column_value;
;; Assigned in scan_column(), used in decode_fn()
;; byte column_changed;
;; Assigned in decode_fn()
;; 26 \ byte key_matrix[18];
;; 37 / Zeroed in init_vars(), used in scan_column(), current/old state of key matrix?
;; 38 bool usb1_transmitting;
;; Zeroed in init_vars(), zeroed in do_usb_2() when transmission to endpoint 1 is finished,
;; assigned/waited in process_key()
;; 39 byte idle_rate;
;; Transmitted in response to vendor request 2, assigned from vendor request 0x0A, never used
;; 3A byte protocol;
;; Transmitted in response to vendor request 3, assigned from vendor request 0x0B, never used
;; 3B local in decode_numlock(), decode_fn()
;; 3C byte keycode;
;; assigned/used in decode_fn(), decode_numlock();
;; assigned in find_macro(); used in store_key()
;; 3D bool phantom;
;; Zeroed in init_vars(), scan_column(), used/zeroed in process_key()
;; 3E bool normal_key;
;; Zeroed in init_vars(), assigned in decode_fn(), used/zeroed in process_key(), tested in trigger_numlock()
;; Zeroed in process_key at end of scanning cycle
;; 3F local in find_macro()
;; 40 byte macro_delay_after;
;; Tested in play_macro(), assigned in find_macro()
;; 41 \ word macro_delay;
;; 42 / Assigned found->items[j].delay in play_macro()
;; 43 byte usb_intr_count;
;; Decremented in do_usb_2()
;; 44 bool after_macro;
;; Tested 0x80/zeroed in process_key(); assigned found->items[j].flags in play_macro()
;; 45 bool usb2_transmitting;
;; Zeroed in init_vars(), zeroed in do_usb_2() when transmission to endpoint 2 is finished
;; 46 bool media_report_ready;
;; Assigned in decode_fn(), stop_fn(); tested/zeroed in process_key()
;; 47 byte media_keycode;
;; Zeroed in init_vars(), used in decode_fn() as Fn-pretranslated keycode, zeroed in stop_fn(),
;; used in process_fn() as switch
;; 48 \ byte hid_report2[2];
;; 49 / Assigned in process_fn(), stop_fn(), transmitted in process_key()
;; 4A byte keydown_index;
;; Zeroed in init_vars(), process_key(); loop count in process_key();
;; tested/incremented in store_key()
;; 4B union {
;; byte hid_report[8];
;; struct {
;; byte key_modifiers;
;; bits: [RWin RAlt RShift RCtrl LWin LAlt LShift LCtrl]
;; used in process_shift_f12(), process_key()
;; 4C byte hid_reserved;
;; 4D byte keys_down[6];
;; 52 } }
;; Zeroed in init_vars(), process_key() after transmitting, assigned in process_key().
;; keys_down[0] == 0xDF in decode_fn() when Fn is down.
;; keys_down[0] == keys_down[1] == 0 in decode_fn() stops Fn.
;; keys_down[0], keys_down[1] used in process_shift_f12()
;; keys_down[0], keys_down[1], keys_down[2] tested/assigned in process_key()
;; 53 local loop counters in two_bits_set(), same_column_value(), decode_fn(),
;; decode_numlock(), process_key(), find_macro(), play_macro()
;; 54 local loop counters in find_macro(), play_macro()
;; 55 locals in play_macro(), process_key()
;; 56 locals in scan_column(), two_bits_set(), same_column_value(), decode_fn(),
;; find_macro(), play_macro()
;; 57 \ struct MacroBinding* pBinding
;; 58 / scans memory in find_macro(); corrupted in play_macro() for no reason
;; 59 \ union { MacroData* pMacro; MacroEvent* pMacroEvent; }
;; 5A / Assigned in find_macro() to found->pointer, used in play_macro()
;; 5B \ hardware stack
;; 7F / 37 bytes
;; :
;; BC \ byte clockA[18];
;; CD /
;; CE \ byte clockB[18];
;; DF /
;; E0 \ struct PressedKey { byte keyindex; byte layer; } pressed_keys[15];
;; FD /
;;
;; XRAM:
;; 0000 byte delay_count;
;; Decremented by timer0(). timer0() fires every 1000*12 clocks which means 1ms at 12MHz.
;; initialized and waited for 0 by delay()
;; 0001 byte wdtcr;
;; Used in timer0(), usb_intr(), keypad()
;; 0003 byte fn_down; // 0x80 if down, 0 if up
;; Zeroed in init_vars(), assigned/used in process_key()
;; 0004 byte numlock_timer;
;; 0005 byte numlock_state;
;; Zeroed in int_vars()
;; Transition from 0x00 to 0xEA in trigger_numlock() if internal numlock is on and a key is pressed
;; Transition from 0xEA to 0xCC in numlock_on() if internal numlock is on, external off, turning external numlock on
;; Transition from 0xCC to 0x88 in process_key() if all keys are released, setting timer to 0xFF
;; Transition from 0x88 to 0xBB in do_delay() when timer expires
;; Transition from 0xBB to 0x00 in numlock_off(), toggling external numlock [off unless interfered with externally]
;; 0007 byte media_key_down;
;; Zeroed in init_vars(), used in decode_fn()
;; 000A byte isp_state;
;; Zeroed in init_isp()
;; Transition without check from 0x00 to the type of current request in isp_reprogram() called from do_receive()
;; Value 0x44 in do_transmit() triggers soft reboot
;; Transition from 0x55 to 0x00 in isp_read_block() sending report 55 AA 00 28 // version check?
;; In state 0x66 in isp_read_block() read 64 bytes from code/constant memory, prepare for transmitting
;; Transition from 0x66 to 0x00 in isp_read_block() when isp_count == 0
;; Transition from any to 0x00 in isp_reprogram() when localX65 >= isp_count resetting localX65 to isp_count (isp_count becomes 0 shortly after)
;; 000B \ byte* isp_ptr;
;; 000C |
;; 000D | Address for ISP read/write operation in isp(), zeroed in init_isp()
;; 000E /
;; 000F \ dword isp_count;
;; 0010 | Count of pages for isp_erase_pages()
;; 0011 | Count of bytes in isp_reprogram() case 0x66 (read macros), 0x77 (erase and write macros)
;; 0012 / Zeroed in init_isp()
;; 0013 local loop counts in isp_reprogram(), isp_erase_pages(), isp_read_block()
;; 0014 bool remote_wakeup;
;; Used in get_status(), clear_feature(), set_feature(), do_usb_2(), zeroed in init_hw()
;; 0015 bool configured;
;; Used in do_usb_2(), assigned in set_configuration(), zeroed in init_hw(),
;; used in process_key()
;; 0016 byte request_state;
;; Transition to 0xF0 in do_receive() on overwrite
;; Transition from 0xF0 to 0x5A on short GET requests
;; Transition from 0xF0 to 0xA5 on short SET requests
;; Transition from 0xF0 to 0x55 on set_address request
;; Transition from 0xF0 to 0x22 on get_macros request
;; Transition from 0xF0 to 0x33 on set_macros request
;; Transition from 0x33 to 0xA5 after set_macros done
;; 0017 union {
;; struct Report report;
;; struct Request request = {
;; byte bmRequestType;
;; 0018 byte bRequest;
;; 0019 __low_endian word wValue;
;; 001A
;; 001B __low_endian word wIndex;
;; 001C
;; 001D __low_endian word wLength;
;; 001E
;; :
;; 0056 }}
;; 0057 enum AddressingMode {
;; RAM_8 = 0,
;; XRAM_16 = 1,
;; XRAM_8 = 0xFE,
;; CMEM_16 // all other values; 0xFF used explicitly
;; } transmit_addr_mode;
;; 0058 \ byte* to_transmit;
;; 0059 /
;; 005B byte max_transmit;
;; Used in do_transmit(), assigned 0x40 in init_hw()
;; 005C \ word tx_rx_count
;; 005D / Byte count in do_receive(), vendor_request(), do_transmit(), get_status(),
;; assigned by get_descriptor(), get_interface()
;; 005E union { byte usb_address; byte usb_configuration; } // minor wtf
;; Assigned in set_configuration(), set_address request
;; 005F \ word requested_size
;; 0060 / Assigned in get_descriptor()
;; 0063 local working copy of UPCON and UIFLG in do_usb_2()
;; 0064 local counts in do_receive(), do_transmit(); local word-sized response size in get_descriptor()
;; 0065 local copy of addressing mode in receive(), transmit()
;; local copy of size argument in isp_reprogram()
;; 0066 \ local copy of base address argument in receive(), transmit()
;; 0067 /
;; 023F XRAMTOP
;;
;;
;; Const section:
;;
;; 2800 struct Macros macros = {
;; byte disabled[0x20];
;; Bit array, each bit corresponding to a keycode. A 0 indicates that for this keycode
;; a corresponding array of macros is present
;; 2820 byte binding_count;
;; 2821 MacroBinding bindings[binding_count];
;; ???? byte data[];
;; };
;;
;; struct MacroBinding {
;; byte keycode; // Structures with same keycode go contiguously
;; byte modifiers; // [0 0 0 0 0 Alt Shift Ctrl]
;; MacroData* pItems;
;; bool delay_after; // if 0, exits immediately after playing;
;; // otherwise, after 100 interrupts or when any key is pressed
;; };
;;
;; struct {
;; 00: byte count;
;; 01: struct MacroEvent {
;; 00: byte hid_report[8];
;; 08: word delay:12;
;; 09: byte flags:4;
;; 0x80 Send an empty report after this (release all keys)
;; 0x40 ?
;; 0x20 ?
;; 0x10 ?
;; } items[];
;; } MacroData;
;;
;;
;; Code
;; ====
;;
CSEG AT 0000h
0000 021B31 LJMP START
;;; free 10 bytes
CSEG AT 000Bh
000B 021A14 LJMP DO_TIMER0
get_status: ;void get_status() {
000E 785C MOV R0, #5Ch
0010 E4 CLR A
0011 F2 MOVX @R0, A
0012 08 INC R0
0013 7402 MOV A, #2h
0015 F2 MOVX @R0, A ; tx_rx_count = 2;
0016 E4 CLR A
0017 7818 MOV R0, #18h
0019 F2 MOVX @R0, A ; report[1] = 0;
001A 18 DEC R0
001B E2 MOVX A, @R0
001C 5403 ANL A, #3h ; switch (request.bmRequestType & 3) { // Recipient
001E 14 DEC A
001F 6043 JZ L0337 ; // case 1
0021 14 DEC A
0022 6014 JZ L0338 ; // case 2
0024 2402 ADD A, #2h
0026 7035 JNZ L0339 ; case 0: // Device
0028 7814 MOV R0, #14h
002A E2 MOVX A, @R0
002B 6006 JZ L0340 ; if (remote_wakeup != 0) {
002D 7817 MOV R0, #17h
002F 7402 MOV A, #2h
0031 F2 MOVX @R0, A ; report[0] = 2; // Remote wakeup
0032 22 RET
L0340: ; } else {
0033 E4 CLR A
0034 7817 MOV R0, #17h
0036 F2 MOVX @R0, A ; report[0] = 0;
0037 22 RET ; }
; break;
L0338: ; case 2: // Endpoint
0038 781B MOV R0, #1Bh
003A E2 MOVX A, @R0
003B 540F ANL A, #0Fh
003D 90FFF1 MOV DPTR, #0FFF1h
0040 F0 MOVX @DPTR, A ; EPINDEX = LOBYTE(request.wIndex) & 0x0F;
0041 90FFE1 MOV DPTR, #0FFE1h
0044 E0 MOVX A, @DPTR
0045 20E704 JB ACC.7, L0341 ; if (EPCON.RXSTL
0048 E0 MOVX A, @DPTR
0049 30E607 JNB ACC.6, L0342 ; or EPCON.TXSTL) {
L0341:
004C 7817 MOV R0, #17h
004E 7401 MOV A, #1h
0050 F2 MOVX @R0, A ; report[0] = 1; // Halt
0051 8004 SJMP L0343
L0342: ; } else {
0053 E4 CLR A
0054 7817 MOV R0, #17h
0056 F2 MOVX @R0, A ; report[0] = 0;
L0343: ; }
0057 90FFF1 MOV DPTR, #0FFF1h
005A E4 CLR A
005B F0 MOVX @DPTR, A ; EPINDEX = 0;
005C 22 RET ; break;
L0339: ; case 3:
005D 90FFE1 MOV DPTR, #0FFE1h
0060 E0 MOVX A, @DPTR
0061 44C0 ORL A, #0C0h
0063 F0 MOVX @DPTR, A ; EPCON.RXSTL = EPCON.TXSTL = 0;
; // fallthrough
L0337: ; case 1:
0064 22 RET ;} }
set_ISPCR: ;void set_ISPCR(byte __register(R7) value) {
0065 8FE7 MOV 0E7h, R7 ; ISPCR = value;
0067 22 RET ;}
CSEG AT 006Bh
006B 02164C LJMP DO_KEYPAD
init_all: ;void init_all() {
006E 1215E4 LCALL init_interrupts ; init_interrupts();
0071 121AC6 LCALL init_isp ; init_isp();
0074 12177E LCALL init_vars ; init_vars();
0077 021805 LJMP init_hw ; init_hw();
;}
CSEG AT 007Bh
007B 021A57 LJMP DO_USB
process_key: ;void process_key() {
007E 7815 MOV R0, #15h
0080 E2 MOVX A, @R0
0081 7003 JNZ L0021 ; if (configured) {
0083 02043C LJMP L0022
L0021:
0086 7823 MOV R0, #23h
0088 E6 MOV A, @R0
0089 6412 XRL A, #12h
008B 6003 JZ L0023 ; if (column_index == sizeof(key_matrix)) {
008D 0203E0 LJMP L0024
L0023:
0090 783D MOV R0, #3Dh
0092 E6 MOV A, @R0
0093 6052 JZ L0037 ; if (phantom) {
0095 E4 CLR A
0096 784B MOV R0, #4Bh
0098 F6 MOV @R0, A ; key_modifiers = 0;
0099 08 INC R0
009A F6 MOV @R0, A ; hid_reserved = 0;
009B 08 INC R0
009C 7601 MOV @R0, #1h ; keys_down[0] = 1;
009E 08 INC R0
009F 7601 MOV @R0, #1h ; keys_down[1] = 1;
00A1 08 INC R0
00A2 7601 MOV @R0, #1h ; keys_down[2] = 1;
00A4 08 INC R0
00A5 7601 MOV @R0, #1h ; keys_down[3] = 1;
00A7 08 INC R0
00A8 7601 MOV @R0, #1h ; keys_down[4] = 1;
00AA 08 INC R0
00AB 7601 MOV @R0, #1h ; keys_down[5] = 1;
00AD C2AF CLR EA ; __uninterrupted {
00AF 90FFF1 MOV DPTR, #0FFF1h
00B2 04 INC A
00B3 F0 MOVX @DPTR, A ; EPINDEX = 1;
00B4 E4 CLR A
00B5 08 INC R0
00B6 F6 MOV @R0, A
L0038: ; for (byte __volatile(v53) i = 0; i != 8; ++i) {
00B7 7853 MOV R0, #53h
00B9 E6 MOV A, @R0
00BA 244B ADD A, #4Bh
00BC F8 MOV R0, A
00BD E6 MOV A, @R0
00BE 90FFF3 MOV DPTR, #0FFF3h
00C1 F0 MOVX @DPTR, A ; TXDAT = hid_report[i];
00C2 7853 MOV R0, #53h
00C4 06 INC @R0
00C5 E6 MOV A, @R0
00C6 B408EE CJNE A, #8h, L0038 ; }
00C9 7838 MOV R0, #38h
00CB 7601 MOV @R0, #1h ; usb1_transmitting = 1;
00CD 7853 MOV R0, #53h
00CF E6 MOV A, @R0
00D0 90FFF6 MOV DPTR, #0FFF6h
00D3 F0 MOVX @DPTR, A ; TXCNT = i; // 8
00D4 90FFF1 MOV DPTR, #0FFF1h
00D7 E4 CLR A
00D8 F0 MOVX @DPTR, A ; EPINDEX = 0;
00D9 D2AF SETB EA ; }
L0042: ; do {
00DB 7838 MOV R0, #38h
00DD E6 MOV A, @R0
00DE 6401 XRL A, #1h
00E0 6003 JZ L0039 ; } while (usb1_transmitting == 1);
00E2 0203E0 LJMP L0024
L0039:
00E5 80F4 SJMP L0042
L0037: ; } else // not phantom
00E7 783E MOV R0, #3Eh
00E9 E6 MOV A, @R0
00EA 7003 JNZ L0043 ; if (normal_key) {
00EC 0203E0 LJMP L0024
L0043:
00EF 12191E LCALL process_shift_f12 ; process_shift_f12();
00F2 7821 MOV R0, #21h
00F4 E6 MOV A, @R0
00F5 645A XRL A, #5Ah
00F7 6003 JZ L0045 ; if (kb_mode == KBMODE_NORMAL) {
00F9 02030C LJMP L0046
L0045:
00FC 02027B LJMP L9800
pc_fn_keycodes: ;static const byte pc_fn_keycodes[18*8] = {
00FF 00008B0000000000 ; 0, 0, Muhen, 0, 0, 0, 0, 0,
0107 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
010F 0000004700000000 ; 0, 0, 0, Scroll, 0, 0, 0, 0,
0117 0000490000000000 ; 0, 0, Ins, 0, 0, 0, 0, 0,
011F 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
0127 0000004600000000 ; 0, 0, 0, PrtScr, 0, 0, 0, 0,
012F 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
0137 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
013F 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
0147 00E900EA00930000 ; 0, Media1, 0, Media2, 0, Hiragana, 0, 0,
014F 00EBF5EC00000000 ; 0, Media3, Media13,Media4, 0, 0, 0, 0,
0157 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
015F 000000AD00000000 ; 0, 0, 0, WinBrk, 0, 0, 0, 0,
0167 00AE000000000000 ; 0, CtrlBrk,0, 0, 0, 0, 0, 0,
016F 00ED00EE00000000 ; 0, Media5, 0, Media6, 0, 0, 0, 0,
0177 00EF00F000000000 ; 0, Media7, 0, Media8, 0, 0, 0, 0,
017F 00F100F200000000 ; 0, Media9, 0, Media10, 0, 0, 0, 0,
0187 00F300F400000000 ; 0, Media11,0, Media12, 0, 0, 0, 0
;}
mac_fn_keycodes: ;static const byte mac_fn_keycodes[18*8] = {
018F 00008B0000000000 ; 0, 0, Muhen, 0, 0, 0, 0, 0,
0197 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
019F 0000004700000000 ; 0, 0, 0, Scroll, 0, 0, 0, 0,
01A7 0000490000000000 ; 0, 0, Ins, 0, 0, 0, 0, 0,
01AF 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
01B7 0000004600000000 ; 0, 0, 0, PrtScr, 0, 0, 0, 0,
01BF 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
01C7 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
01CF 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
01D7 00E900EA00930000 ; 0, Media1, 0, Media2, 0, Hiragana, 0, 0,
01DF 00EBF5EC00000000 ; 0, Media3, Media13,Media4, 0, 0, 0, 0,
01E7 0000000000000000 ; 0, 0, 0, 0, 0, 0, 0, 0,
01EF 000000AD00000000 ; 0, 0, 0, WinBrk, 0, 0, 0, 0,
01F7 00AE000000000000 ; 0, CtrlBrk,0, 0, 0, 0, 0, 0,
01FF 00ED00EE00000000 ; 0, Media5, 0, Media6, 0, 0, 0, 0,
0207 00EF00F000000000 ; 0, Media7, 0, Media8, 0, 0, 0, 0,
020F 00F100F200000000 ; 0, Media9, 0, Media10, 0, 0, 0, 0,
0217 00F300F400000000 ; 0, Media11,0, Media12, 0, 0, 0, 0
;}
;;; 81 bytes code
do_get_keycode: ;byte __register(R7) do_get_keycode(byte __register(R7) keyindex, byte __register(A) layer)
021F 900226 MOV DPTR, #0226h
0222 5407 ANL A, #7h
0224 23 RL A
0225 73 JMP @A+DPTR
0226 8025 SJMP L9200
0228 801C SJMP L9201
022A 800A SJMP L9202
022C 8011 SJMP L9203
022E 8039 SJMP L9204
0230 8030 SJMP L9205
0232 801E SJMP L9206
0234 8025 SJMP L9207 ; switch (layer & 7)
; {
L9202: ; case 2: // PC Fn
0236 9000FF MOV DPTR, #00FFh
0239 EF MOV A, R7
023A 93 MOVC A, @A+DPTR ; A = pc_fn_keycodes[keyindex];
023B 7031 JNZ L9209 ; if (A) return A;
023D 800E SJMP L9200 ; goto case 0;
L9203: ; case 3: // PC Fn Num
023F 9000FF MOV DPTR, #00FFh
0242 EF MOV A, R7
0243 93 MOVC A, @A+DPTR ; A = pc_fn_keycodes[keyindex];
0244 7028 JNZ L9209 ; if (A) return A;
L9201: ; case 1: // PC Num
0246 9008AE MOV DPTR, #08AEh
0249 EF MOV A, R7
024A 93 MOVC A, @A+DPTR ; A = pc_num_keycodes[keyindex];
024B 7021 JNZ L9209 ; if (A) return A;
L9200: ; case 0: // PC Main
024D 90072B MOV DPTR, #072Bh ; A = pc_keycodes[keyindex];
0250 801A SJMP L9208 ; return A;
L9206: ; case 6: // Mac Fn
0252 90018F MOV DPTR, #018Fh
0255 EF MOV A, R7
0256 93 MOVC A, @A+DPTR ; A = mac_fn_keycodes[keyindex];
0257 7015 JNZ L9209 ; if (A) return A;
0259 800E SJMP L9204 ; goto case 4;
L9207: ; case 7: // Mac Fn Num
025B 90018F MOV DPTR, #018Fh
025E EF MOV A, R7
025F 93 MOVC A, @A+DPTR ; A = mac_fn_keycodes[keyindex];
0260 700C JNZ L9209 ; if (A) return A;
L9205: ; case 5: // Mac Num
0262 900A8E MOV DPTR, #0A8Eh
0265 EF MOV A, R7
0266 93 MOVC A, @A+DPTR ; A = mac_num_keycodes[keyindex];
0267 7005 JNZ L9209 ; if (A) return A;
L9204: ; case 4: // Mac Main
0269 9007BB MOV DPTR, #07BBh
L9208:
026C EF MOV A, R7
026D 93 MOVC A, @A+DPTR ; A = mac_keycodes[keyindex];
L9209:
026E FF MOV R7, A
026F 22 RET ; return A;
; }
;}
;;; 11 bytes free
CSEG AT 027Bh
L9800:
027B 784D MOV R0, #4Dh
027D E6 MOV A, @R0
027E B4AD04 CJNE A, #0ADh, L9401 ; if (keys_down[0] == 0xAD) { // WinBrk
0281 7480 MOV A, #80h
0283 8005 SJMP L9402 ; key_modifiers.RWin = true;
; keys_down[0] = 0x48; // Pause
; } else
L9401:
0285 B4AE0A CJNE A, #0AEh, L0104 ; if (keys_down[0] == 0xAE) { // CtrlBrk
0288 7410 MOV A, #10h
L9402:
028A 784B MOV R0, #4Bh
028C 46 ORL A, @R0
028D F6 MOV @R0, A ; key_modifiers.RCtrl = true;
028E 784D MOV R0, #4Dh
0290 7648 MOV @R0, #48h ; keys_down[0] = 0x48; // Pause
L0104: ; }
0292 121502 LCALL numlock_on ; numlock_on();
0295 7805 MOV R0, #5h
0297 E2 MOVX A, @R0
0298 B48807 CJNE A, #88h, L0115 ; if (numlock_state == 0x88) {
029B E4 CLR A
029C 18 DEC R0
029D F2 MOVX @R0, A ; numlock_timer = 0;
029E 08 INC R0
029F 74CC MOV A, #0CCh
02A1 F2 MOVX @R0, A ; numlock_state = 0xCC;
L0115: ; }
02A2 C2AF CLR EA ; __uninterrupted {
02A4 90FFF1 MOV DPTR, #0FFF1h
02A7 7401 MOV A, #1h
02A9 F0 MOVX @DPTR, A ; EPINDEX = 1;
02AA E4 CLR A
02AB 7853 MOV R0, #53h
02AD F6 MOV @R0, A
L0116: ; for (byte __volatile(v53) i = 0; i != 8; ++i) {
02AE 7853 MOV R0, #53h
02B0 E6 MOV A, @R0
02B1 244B ADD A, #4Bh
02B3 F8 MOV R0, A
02B4 E6 MOV A, @R0
02B5 90FFF3 MOV DPTR, #0FFF3h
02B8 F0 MOVX @DPTR, A ; TXDAT = hid_report[i];
02B9 7853 MOV R0, #53h
02BB 06 INC @R0
02BC E6 MOV A, @R0
02BD B408EE CJNE A, #8h, L0116 ; }
02C0 7838 MOV R0, #38h
02C2 7601 MOV @R0, #1h ; usb1_transmitting = 1;
02C4 7853 MOV R0, #53h
02C6 E6 MOV A, @R0
02C7 90FFF6 MOV DPTR, #0FFF6h
02CA F0 MOVX @DPTR, A ; TXCNT = i; // 8
02CB 90FFF1 MOV DPTR, #0FFF1h
02CE E4 CLR A
02CF F0 MOVX @DPTR, A ; EPINDEX = 0;
02D0 D2AF SETB EA ; }
L0117: ; do {
02D2 7838 MOV R0, #38h
02D4 E6 MOV A, @R0
02D5 6401 XRL A, #1h
02D7 60F9 JZ L0117 ; } while (usb1_transmitting == 1);
02D9 784B MOV R0, #4Bh
02DB E6 MOV A, @R0
02DC 6003 JZ L0118 ; if (key_modifiers == 0
02DE 0203E0 LJMP L0024
L0118:
02E1 784D MOV R0, #4Dh
02E3 E6 MOV A, @R0
02E4 6003 JZ L0119 ; and keys_down[0] == 0
02E6 0203E0 LJMP L0024
L0119:
02E9 08 INC R0
02EA E6 MOV A, @R0
02EB 6003 JZ L0120 ; and keys_down[1] == 0
02ED 0203E0 LJMP L0024
L0120:
02F0 7804 MOV R0, #4h
02F2 E2 MOVX A, @R0
02F3 6003 JZ L0121 ; and numlock_timer == 0
02F5 0203E0 LJMP L0024
L0121:
02F8 08 INC R0
02F9 E2 MOVX A, @R0
02FA 64CC XRL A, #0CCh
02FC 6003 JZ L0122 ; and numlock_state == 0xCC)
02FE 0203E0 LJMP L0024
L0122: ; {
0301 18 DEC R0
0302 74FF MOV A, #0FFh
0304 F2 MOVX @R0, A ; numlock_timer = 0xFF;
0305 08 INC R0
0306 7488 MOV A, #88h
0308 F2 MOVX @R0, A ; numlock_state = 0x88;
0309 0203E0 LJMP L0024
; }
L0046: ; } else /*kb_mode != 0x5A*/
030C 7844 MOV R0, #44h
030E E6 MOV A, @R0
030F B48010 CJNE A, #80h, L0047 ; if (after_macro == 0x80
0312 784B MOV R0, #4Bh
0314 E6 MOV A, @R0
0315 700B JNZ L0047 ; and key_modifiers == 0
0317 784D MOV R0, #4Dh
0319 E6 MOV A, @R0
031A 7006 JNZ L0047 ; and keys_down[0] == 0)
031C 7844 MOV R0, #44h ; {
031E F6 MOV @R0, A ; after_macro = 0;
031F 0203E0 LJMP L0024
L0047: ; } else {
0322 E4 CLR A
0323 784A MOV R0, #4Ah
0325 F6 MOV @R0, A
L0054: ; for (keydown_index = 0; keydown_index < 6 and keys_down[keydown_index]; ) {
0326 784A MOV R0, #4Ah
0328 E6 MOV A, @R0
0329 C3 CLR C
032A 9406 SUBB A, #6h
032C 4003 JC L0048
032E 0203E0 LJMP L0024
L0048:
0331 120B69 LCALL find_macro ; if (find_macro(&keydown_index)) {
0334 500C JNC L0050
0336 12043D LCALL play_macro ; play_macro();
0339 784A MOV R0, #4Ah
033B 06 INC @R0 ; ++keydown_index;
033C 7844 MOV R0, #44h
033E 7680 MOV @R0, #80h ; after_macro = 0x80;
0340 805D SJMP L0052 ; continue;
L0050: ; }
0342 E4 CLR A
0343 7844 MOV R0, #44h
0345 F6 MOV @R0, A ; after_macro = 0;
0346 C2AF CLR EA ; __uninterrupted {
0348 90FFF1 MOV DPTR, #0FFF1h
034B 04 INC A
034C F0 MOVX @DPTR, A ; EPINDEX = 1;
034D 784B MOV R0, #4Bh
034F E6 MOV A, @R0
0350 90FFF3 MOV DPTR, #0FFF3h
0353 F0 MOVX @DPTR, A ; TXDAT = key_modifiers;
0354 08 INC R0
0355 E6 MOV A, @R0
0356 F0 MOVX @DPTR, A ; TXDAT = hid_reserved;
0357 E4 CLR A
0358 7855 MOV R0, #55h
035A F6 MOV @R0, A
L0081: ; for (byte __volatile(v55) k = 0; j < 6 and not find_macro(keydown_index); ++keydown_index, ++k) {
035B 784A MOV R0, #4Ah
035D E6 MOV A, @R0
035E C3 CLR C
035F 9406 SUBB A, #6h
0361 5014 JNC L0080
0363 120B69 LCALL find_macro
0366 400F JC L0080
0368 783C MOV R0, #3Ch
036A E6 MOV A, @R0
036B 90FFF3 MOV DPTR, #0FFF3h
036E F0 MOVX @DPTR, A ; TXDAT = keycode;
036F 784A MOV R0, #4Ah
0371 06 INC @R0
0372 7855 MOV R0, #55h
0374 06 INC @R0
0375 80E4 SJMP L0081 ; }
L0080: ; for (; k < 6; ++k) {
0377 7855 MOV R0, #55h
0379 E6 MOV A, @R0
037A C3 CLR C
037B 9406 SUBB A, #6h
037D 5008 JNC L0082
037F 90FFF3 MOV DPTR, #0FFF3h
0382 E4 CLR A
0383 F0 MOVX @DPTR, A ; TXDAT = 0;
0384 06 INC @R0
0385 80F0 SJMP L0080 ; }
L0082:
0387 7838 MOV R0, #38h
0389 7601 MOV @R0, #1h ; usb1_transmitting = 1;
038B 90FFF6 MOV DPTR, #0FFF6h
038E 7408 MOV A, #8h
0390 F0 MOVX @DPTR, A ; TXCON = 8;
0391 90FFF1 MOV DPTR, #0FFF1h
0394 E4 CLR A
0395 F0 MOVX @DPTR, A ; EPINDEX = 0;
0396 D2AF SETB EA ; }
L0083: ; do {
0398 7838 MOV R0, #38h
039A E6 MOV A, @R0
039B 6401 XRL A, #1h
039D 60F9 JZ L0083 ; } while (usb1_transmitting == 1);
L0052:
039F 784A MOV R0, #4Ah
03A1 E6 MOV A, @R0
03A2 C3 CLR C
03A3 9406 SUBB A, #6h
03A5 4003 JC L0053
03A7 020326 LJMP L0054
L0053:
03AA E6 MOV A, @R0
03AB 244D ADD A, #4Dh
03AD F8 MOV R0, A
03AE E6 MOV A, @R0
03AF 602F JZ L0024
03B1 020326 LJMP L0054 ; }
; } }
;;; 44 bytes free
CSEG AT 03E0h
L0024: ; } // column_index == 0x12
03E0 7846 MOV R0, #46h
03E2 E6 MOV A, @R0
03E3 603B JZ L0025 ; if (media_report_ready) {
03E5 C2AF CLR EA ; __uninterrupted {
03E7 90FFF1 MOV DPTR, #0FFF1h
03EA 7402 MOV A, #2h
03EC F0 MOVX @DPTR, A ; EPINDEX = 2;
03ED E4 CLR A
03EE 7853 MOV R0, #53h
03F0 F6 MOV @R0, A
L0026: ; for (byte __volatile(v53) i = 0; i != 2; ++i) {
03F1 7853 MOV R0, #53h
03F3 E6 MOV A, @R0
03F4 2448 ADD A, #48h
03F6 F8 MOV R0, A
03F7 E6 MOV A, @R0
03F8 90FFF3 MOV DPTR, #0FFF3h
03FB F0 MOVX @DPTR, A ; TXDAT = hid_report2[i];
03FC 7853 MOV R0, #53h
03FE 06 INC @R0
03FF E6 MOV A, @R0
0400 B402EE CJNE A, #2h, L0026 ; }
0403 7845 MOV R0, #45h
0405 7601 MOV @R0, #1h ; usb2_transmitting = 1;
0407 7853 MOV R0, #53h
0409 E6 MOV A, @R0
040A 90FFF6 MOV DPTR, #0FFF6h
040D F0 MOVX @DPTR, A ; TXCNT = i; // 2
040E 90FFF1 MOV DPTR, #0FFF1h
0411 E4 CLR A
0412 F0 MOVX @DPTR, A ; EPINDEX = 0;
0413 D2AF SETB EA ; }
L0027: ; do {
0415 7845 MOV R0, #45h
0417 E6 MOV A, @R0
0418 6401 XRL A, #1h
041A 60F9 JZ L0027 ; } while (usb2_transmitting == 1);
041C E4 CLR A
041D 7846 MOV R0, #46h
041F F6 MOV @R0, A ; media_report_ready = 0;
L0025: ; }
0420 7823 MOV R0, #23h
0422 E6 MOV A, @R0
0423 B41216 CJNE A, #12h, L0022 ; if (column_index == sizeof(key_matrix)) {
0426 E4 CLR A
0427 784A MOV R0, #4Ah
0429 F6 MOV @R0, A ; keydown_index = 0;
042A FE MOV R6, A
042B 7F08 MOV R7, #8h
042D FD MOV R5, A
042E FB MOV R3, A
042F 7A00 MOV R2, #0h
0431 794B MOV R1, #4Bh
0433 12105C LCALL memset ; memset(hid_report, 8, 0);
0436 E4 CLR A
0437 783E MOV R0, #3Eh
0439 F6 MOV @R0, A ; normal_key = false;
043A 18 DEC R0
043B F6 MOV @R0, A ; phantom = 0;
L0022: ; } }
043C 22 RET ;}
play_macro: ;void play_macro() {
043D 7859 MOV R0, #59h
043F E6 MOV A, @R0
0440 FF MOV R7, A
0441 08 INC R0
0442 E6 MOV A, @R0
0443 7857 MOV R0, #57h
0445 0205BB LJMP L0055
;; ======================================
;; L0055:
;; 05BB CF XCH A, R7
;; 05BC F6 MOV @R0, A
;; 05BD 08 INC R0
;; 05BE EF MOV A, R7
;; 05BF F6 MOV @R0, A ; vw57 = pMacro;
;; 05C0 020448 LJMP L0056
;; ======================================
L0056: ; for (;;) {
0448 7859 MOV R0, #59h
044A E6 MOV A, @R0
044B FE MOV R6, A
044C 08 INC R0
044D E6 MOV A, @R0
044E F582 MOV DPL, A
0450 8E83 MOV DPH, R6
0452 E4 CLR A
0453 93 MOVC A, @A+DPTR
0454 7855 MOV R0, #55h
0456 F6 MOV @R0, A ; byte __volatile(v55) n = pMacro->count;
0457 785A MOV R0, #5Ah
0459 06 INC @R0
045A E6 MOV A, @R0
045B 18 DEC R0
045C 7001 JNZ L0057
045E 06 INC @R0 ; pMacroEvent = &pMacro->items[0];
L0057:
045F E4 CLR A
0460 7856 MOV R0, #56h
0462 F6 MOV @R0, A ; v56 = 0;
0463 7854 MOV R0, #54h
0465 F6 MOV @R0, A
L0079:
0466 7954 MOV R1, #54h
0468 E7 MOV A, @R1
0469 C3 CLR C
046A 7855 MOV R0, #55h
046C 96 SUBB A, @R0
046D 4003 JC L0058 ; for (byte __volatile(v54) j = 0; j < n; ++j) {
046F 02057A LJMP L0059
L0058:
0472 C2AF CLR EA ; __uninterrupted {
0474 90FFF1 MOV DPTR, #0FFF1h
0477 7401 MOV A, #1h
0479 F0 MOVX @DPTR, A ; EPINDEX = 1;
047A E4 CLR A
047B 7853 MOV R0, #53h
047D F6 MOV @R0, A
L0068: ; for (byte __volatile(v53) i = 0; i < 8; ++i) {
047E 7853 MOV R0, #53h
0480 E6 MOV A, @R0
0481 FF MOV R7, A
0482 C3 CLR C
0483 9408 SUBB A, #8h
0485 5017 JNC L0067
0487 EF MOV A, R7
0488 785A MOV R0, #5Ah
048A 26 ADD A, @R0
048B FF MOV R7, A
048C E4 CLR A
048D 18 DEC R0
048E 36 ADDC A, @R0
048F 8F82 MOV DPL, R7
0491 F583 MOV DPH, A
0493 E4 CLR A
0494 93 MOVC A, @A+DPTR
0495 90FFF3 MOV DPTR, #0FFF3h
0498 F0 MOVX @DPTR, A ; TXDAT = pMacroEvent->hid_report[i];
0499 7853 MOV R0, #53h
049B 06 INC @R0
049C 80E0 SJMP L0068 ; }
L0067:
049E 7853 MOV R0, #53h
04A0 E6 MOV A, @R0
04A1 785A MOV R0, #5Ah
04A3 26 ADD A, @R0
04A4 FF MOV R7, A
04A5 E4 CLR A
04A6 18 DEC R0
04A7 36 ADDC A, @R0
04A8 8F82 MOV DPL, R7
04AA F583 MOV DPH, A
04AC E4 CLR A
04AD 93 MOVC A, @A+DPTR
04AE 7842 MOV R0, #42h
04B0 F6 MOV @R0, A ; LOBYTE(macro_delay) = LOBYTE(pMacroEvent->delay);
04B1 7853 MOV R0, #53h
04B3 06 INC @R0 ; ++i; // 9
04B4 E6 MOV A, @R0
04B5 785A MOV R0, #5Ah
04B7 26 ADD A, @R0
04B8 FF MOV R7, A
04B9 E4 CLR A
04BA 18 DEC R0
04BB 36 ADDC A, @R0
04BC 8F82 MOV DPL, R7
04BE F583 MOV DPH, A
04C0 E4 CLR A
04C1 93 MOVC A, @A+DPTR
04C2 7841 MOV R0, #41h
04C4 F6 MOV @R0, A ; HIBYTE(macro_delay) = HIBYTE(pMacroEvent->delay) | pMacroEvent->flags;
04C5 E6 MOV A, @R0
04C6 54F0 ANL A, #0F0h
04C8 7944 MOV R1, #44h
04CA F7 MOV @R1, A ; after_macro = pMacroEvent.flags;
04CB E6 MOV A, @R0
04CC 540F ANL A, #0Fh
04CE F6 MOV @R0, A ; HIBYTE(macro_delay) = HIBYTE(pMacroEvent->delay);
04CF 7838 MOV R0, #38h
04D1 7601 MOV @R0, #1h ; usb1_transmitting = 1;
; // FIXME:
04D3 7853 MOV R0, #53h ; // 00 NOP
04D5 E6 MOV A, @R0 ; // 7408 MOV A, #08h
04D6 90FFF6 MOV DPTR, #0FFF6h
04D9 F0 MOVX @DPTR, A ; TXCNT = i; // 9??
04DA 90FFF1 MOV DPTR, #0FFF1h
04DD E4 CLR A
04DE F0 MOVX @DPTR, A ; EPINDEX = 0;
04DF D2AF SETB EA ; }
L0069: ; do {
04E1 7838 MOV R0, #38h
04E3 E6 MOV A, @R0
04E4 6401 XRL A, #1h
04E6 60F9 JZ L0069 ; } while (usb1_transmitting == 1);
04E8 785A MOV R0, #5Ah
04EA 740A MOV A, #0Ah
04EC 26 ADD A, @R0
04ED F6 MOV @R0, A
04EE 18 DEC R0
04EF E4 CLR A
04F0 36 ADDC A, @R0
04F1 F6 MOV @R0, A ; ++pMacroEvent; // to found->items[j+1]
04F2 7843 MOV R0, #43h
04F4 7615 MOV @R0, #15h ; usb_intr_count = 0x15; // 21
L0070: ; do {
04F6 7843 MOV R0, #43h
04F8 E6 MOV A, @R0
04F9 70FB JNZ L0070 ; } while (usb_intr_count); // wait for 21 USB interrupts?
04FB 7844 MOV R0, #44h
04FD E6 MOV A, @R0
04FE 20E731 JB ACC.7, L0071 ; if (not after_macro.7) {
0501 C2AF CLR EA ; __uninterrupted {
0503 90FFF1 MOV DPTR, #0FFF1h
0506 7401 MOV A, #1h
0508 F0 MOVX @DPTR, A ; EPINDEX = 1;
0509 E4 CLR A
050A 7853 MOV R0, #53h
050C F6 MOV @R0, A
L0072: ; for (byte __volatile(v53) i = 0; i != 8; ++i) {
050D 90FFF3 MOV DPTR, #0FFF3h
0510 E4 CLR A
0511 F0 MOVX @DPTR, A ; TXDAT = 0;
0512 7853 MOV R0, #53h
0514 06 INC @R0
0515 E6 MOV A, @R0
0516 B408F4 CJNE A, #8h, L0072 ; }
0519 7838 MOV R0, #38h
051B 7601 MOV @R0, #1h ; usb1_transmitting = 1;
051D 7853 MOV R0, #53h
051F E6 MOV A, @R0
0520 90FFF6 MOV DPTR, #0FFF6h
0523 F0 MOVX @DPTR, A ; TXCNT = i; // 8
0524 90FFF1 MOV DPTR, #0FFF1h
0527 E4 CLR A
0528 F0 MOVX @DPTR, A ; EPINDEX = 0;
0529 D2AF SETB EA ; }
L0073: ; do {
052B 7838 MOV R0, #38h
052D E6 MOV A, @R0
052E 6401 XRL A, #1h
0530 60F9 JZ L0073 ; } while (usb1_transmitting == 1);
L0071: ; } // if after_macro.7
0532 7842 MOV R0, #42h
0534 E6 MOV A, @R0
0535 18 DEC R0
0536 46 ORL A, @R0
0537 603B JZ L0074 ; if (macro_delay) {
0539 7843 MOV R0, #43h
053B 7632 MOV @R0, #32h ; usb_intr_count = 0x32; // 50
L0075: ; do {
053D 7843 MOV R0, #43h
053F E6 MOV A, @R0
0540 70FB JNZ L0075 ; } while (usb_intr_count);
0542 7842 MOV R0, #42h
0544 E6 MOV A, @R0
0545 16 DEC @R0
0546 18 DEC R0
0547 7001 JNZ L0076
0549 16 DEC @R0 ; --macro_delay;
L0076:
054A 7842 MOV R0, #42h