converter/ibm4704_usb/ibm4704.txt

   1 IBM 4704 Keyboard Analysis - 6019284(62-key)
   2 ============================================
   3 2013/02/09, 2019/07/12
   4
   5 IBM 4704 Keyboard
   6 =================
   7 IBM capacitive switch models:
   8     6019273 Model 100 50-key (grid layout)      http://kishy.ca/?p=894
   9     6019284 Model 200 62-key Alpha(60% layout)  http://kishy.ca/?p=894
  10     6019303 Model 300 77-key Expanded Alpha     http://deskthority.net/photos-f62/ibm-6019303-t8502.html
  11     6020218 Model 400 107-key Full key          http://kishy.ca/?p=894
  12
  13 Alps switch(vintage Green) models:
  14     5954339 Japanese 102-key    http://deskthority.net/post87127.html#p87127
  15     6112883 Japanese 102-key    http://geekhack.org/index.php?topic=52888.msg1194489#msg1194489
  16     6112884 Japanese 102-key    http://geekhack.org/index.php?topic=50437.msg1193047#msg1193047
  17     6341739 Chinese 102-key     http://geekhack.org/index.php?topic=52888.msg1176566#msg1176566
  18
  19
  20
  21 Resourse
  22 --------
  23 The IBM 4704: lots of pictures and info
  24 http://kishy.ca/?p=894
  25 http://imgur.com/a/LaABs
  26
  27 Brochure:
  28 http://ed-thelen.org/comp-hist/IBM-ProdAnn/4700.pdf
  29
  30
  31
  32 4704 Keyboard Protocol
  33 ======================
  34 On powering up keyboard sends keyboard ID; A3h for 6019284(62-key), for example.
  35 After that the keyboard enters FC command mode and waits for parameter data from host
  36 so that it doesn't send any scancode until you send 'FF'(End of FC command mode).
  37
  38
  39     Keyboard                    ID
  40     -------------------------------
  41     Model 100 50-key            A2h
  42     Model 200 62-key            A3h
  43     Model 300 77-key            A4h
  44     Model 400 107-key           A5h
  45     Japanese/Chinese 102-key    A6h
  46
  47
  48 Connector
  49 ---------
  50     Keyboard Plug from front
  51
  52     DSUB-9
  53     -------------
  54     \ N 2 3 4 5 /
  55      \ N N N N /
  56       ---------
  57     2   GND
  58     3   VCC 5V
  59     4   DATA
  60     5   CLOCK
  61     N   No connection/No pin.
  62
  63
  64 Keyboard to Host
  65 ----------------
  66 Data bits are LSB first and Pairty is odd. Clock has around 60us high and 30us low part.
  67
  68             ____       __   __   __   __   __   __   __   __   __   _______
  69     Clock       \_____/  \_/  \_/  \_/  \_/  \_/  \_/  \_/  \_/  \_/
  70                  ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
  71     Data    ____/    X____X____X____X____X____X____X____X____X____X________
  72                 Start   0    1    2    3    4    5    6    7    P  Stop
  73
  74 Start bit:  can be long as 300-350us.
  75 Inhibit:    Pull Data line down to inhibit keyboard to send.
  76 Timing:     Host reads bit while Clock is hi.(rising edge)
  77 Stop bit:   Keyboard pulls down Data line to lo after 9th clock.
  78
  79
  80
  81 Host to Keyboard
  82 ----------------
  83 Data bits are LSB first and Pairty is odd. Clock has around 60us high and 30us low part.
  84
  85             ____        __   __   __   __   __   __   __   __   __   ________
  86     Clock       \______/  \_/  \_/  \_/  \_/  \_/  \_/  \_/  \_/  \_/
  87                 ^   ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___
  88     Data    ____|__/    X____X____X____X____X____X____X____X____X____X   \___
  89                 |  Start   0    1    2    3    4    5    6    7    P   Stop
  90                 Request by host
  91
  92 Start bit:  can be long as 300-350us during start up and upto 2500us while key scanning
  93 Request:    Host pulls Clock line down to request to send a command.
  94 Timing:     After Request keyboard pull up Data and down Clock line to low for start bit.
  95             After request host release Clock line once Data line becomes hi.
  96             Host wirtes a bit while Clock is hi and Keyboard reads while low.
  97 Stop bit:   Host releases or pulls up Data line to hi after 9th clock and waits for keybaord pull down the line to lo.
  98
  99
 100
 101 Scancodes
 102 ---------
 103 Keyboard doesn't send Break code for all keys except for Alt by default.
 104
 105     6019284 62-key:
 106     ,-----------------------------------------------------------.
 107     |  `|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|**1|BS |
 108     |-----------------------------------------------------------|
 109     |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P| ￠|  \|  PD2|
 110     |-----------------------------------------------------------|
 111     |Ctrl  |  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '| {}| PD3|
 112     |-----------------------------------------------------------|
 113     |Shif| <>|  Z|  X|  C|  V|  B|  N|  M|  ,|  ,|  /|**2|Shift |
 114     |-----------------------------------------------------------|
 115     |Reset|blk|Alt  |         Space             |Alt  |blk|Enter|
 116     `-----------------------------------------------------------'
 117     +----------+---------------------+----------+----------+
 118     |`       00|PD1     04|Caps    20|LShift  30|Reset   31|
 119     |1       18|q       05|a       21|<>      3E|Rblank  41|
 120     |2       19|w       06|s       22|z       32|Alt     3F|
 121     |3       1A|e       13|d       23|x       33|Space   40|
 122     |4       10|r       14|f       24|c       34|Alt     3F|
 123     |5       11|t       15|g       25|v       35|Lblank  42|
 124     |6       12|y       16|h       26|b       36|Enter   2F|
 125     |7       08|u       17|j       27|n       37|          |
 126     |8       09|i       01|k       28|m       38|          |
 127     |9       0A|o       02|l       29|,       39|          |
 128     |0       0F|p       03|;       2A|.       3A|          |
 129     |-       1F|￠      1B|'       2B|/       3B|          |
 130     |=       0D|\       1C|{}      2C|**2     3C|          |
 131     |**1     0C|PD2     1D|PD3     2D|RShift  3D|          |
 132     |BS      0E|          |          |          |          |
 133     +----------+---------------------+----------+----------+
 134     Bit7 is 'press flag' which set 1 on press and 0 on release when break code is enabled.
 135
 136 NOTE: When break code is enabled the key sends scancode with setting 7th bit on press
 137 and without it on release. That is, '`' sends 80h on press and 00h on release.
 138
 139
 140 Keyboard command
 141 ----------------
 142 Keyboard accepts these commands from host.
 143
 144         Description                             Entry point
 145     -----------------------------------------------------------
 146     FF  Soft Reset                              0008h
 147     FE  Resend                                  00e8h
 148     FD  Buzzer(emits a short beep)              00edh
 149     FC  Set Key Flag                            00f6h
 150     FB  Soft Reset                              0008h
 151     FA  Reset                                   0000h
 152
 153
 154 Keyboard response
 155 -----------------
 156 Keyobard sends these bytes to host.
 157
 158         Description                             Entry point
 159     -----------------------------------------------------------
 160     FE  Overflow(key event/receive data)        00c5h, 0346h
 161         Memory test error                       0224h
 162     FD  Command out of bound                    00d8h
 163         Key out of bound
 164     7E  Read/Parity error in receive from host  00bch
 165     80-FB? scan code(make)
 166     00-7B? scan code(break)
 167     note: Alps model spits scan code 7B(FB) at least.
 168
 169
 170 Set Key Flag command(FC)
 171 ------------------------
 172 After 'Power on Reset' firmware enters this command mode and waits for data from host,
 173 so that you don't need to send 'FC' and it doesn't send any scancode until you send 'FF' to exit this mode.
 174 With Alps models you need to send 'FC' command to enter this mode.
 175
 176 Data sent from host:
 177
 178     bit: 7   6 ... 0
 179          en  |     |
 180          |   `-----`--- scan code
 181          `------------- enable bit(0: enable repeat, 1: enable break)
 182
 183     00-7B   Enable repeat
 184     80-FB   Enable break
 185     FE      Resend(011ah) no need to use
 186     FF      End(0114h) exits FC command mode.
 187
 188 Response from keyboard:
 189     FD      Out of bound - Invalid scancode
 190     --      OK - No response means that command is accepted.
 191
 192 Examples:
 193     To enable break code of all keys you have to send following commands.
 194
 195     FC 80 81 ... FB FF
 196
 197
 198
 199 4704 Hardware
 200 =============
 201 Power consumption
 202 -----------------
 203 This keyboard is very power greedy, it consumes around 170mA
 204 and USB port may not be able to supply enough current.
 205
 206     5.061V  -               No load. Power from Powered USB Hub.
 207     4.946V  133.6mA max     without Buzzer
 208     4.911V  171.0mA max     with Buzzer
 209
 210
 211 Controller Board
 212 ----------------
 213 NOTE: TWO BOLTS OF CONTROLLER BOARD IS CRITICAL.
 214 Controller PCB and tab of bottom plate of key assembly with two hex bolts, these
 215 connect between controller ground to the metal bottom plate of key switch assembly.
 216 This connection is very critical to sense key state, keys will not be registered
 217 unless they are tightened up with the bolts
 218
 219     Controller: 8048 DIP40 with 1KB ROM and 64B RAM(8748H?)
 220     Clock:      ??MHz   Resonator? TODO: machine cycle: ??us
 221     Buffer:     7917 hex buffer
 222     Sensor:     IBM custom chip for capacitive sense
 223
 224
 225 8048 Pin configuration
 226 ----------------------
 227 Bus:
 228     bit: D7  D6  D5  D4  D3  D2  D1  D0
 229     use: BZ  CLK DAT ??? G   S2  S1  S0
 230
 231     use dir     description
 232     ----------------------------------------------------------------------
 233     S0  out     Sensor select
 234     S1  out     Sensor select
 235     S2  out     Sensor select
 236     G   out     Sensor strobe?
 237     ???         Sensor state out(drive/charge? via 7917 buffer)
 238     DAT out     Data via buffer logic with 2K pull up resistor
 239     CLK out     Clock via buffer logic with 2K pull up resistor
 240     BZ  out     Drive Buzzer via 7917 buffer with 2KOhm pull up resistor(H:on/L:off)
 241 T0:
 242     input of Sensor state(H:on/L:off)
 243 T1:
 244     input of Clock line with 1KOhm pull up resistor
 245 INT:
 246     input of Data line with 1KOhm pull down resistor
 247 PORT1:
 248     P10-P17 matrix row0-7
 249 PORT2:
 250     P20     matrix row8 or I(keyboard identity bits row)
 251
 252
 253 Connections
 254 -----------
 255     8048            Sensor
 256     -----------------------------
 257     D0-2 ====/===== S0-2(Sensor)
 258     D3   ---------- STR(Sensor)
 259            7917 buffer
 260     D4   --|>--+--- OUT(Sensor)
 261     T0   ------'
 262
 263     8048            line
 264     -----------------------------
 265            Vcc  Vcc
 266             |    |
 267             R 1K R 2K
 268     T1   ---+-<|-+- CLK
 269     D6   ---|>---'
 270                 Vcc
 271                  |
 272                  R 2K
 273     D6   ---|>---+- DAT
 274     T1   -+---<|-'
 275           R 1K
 276           |
 277          GND
 278                 Vcc
 279                  |
 280                  R 2K
 281     D7   ---|>---+- BZ
 282
 283
 284 Interruption
 285 ------------
 286 I       disable at 0015h
 287 TCNTI   disable at 0014h
 288
 289
 290 IBM Capacitive sensor chip
 291 --------------------------
 292 Silver canned package
 293
 294     Pin             Connection      Desciption
 295     ----------------------------------------------------------------
 296     Input(C0-7)     Matrix Col0-7   8 column line inputs
 297     Col select(S0-2)8048:D0-D2      Select column line to sense
 298     Strobe(STR)     8048:D3         Strobe
 299     Output(OUT)     848:T0          Read Key state(0:pressed/1:released)
 300
 301     Pinout from bottom:
 302     +-----------++------+-------+-------+-------+
 303     | 1 2 3 4 5 ||1:LCL |6:LCC  |B:S0   |G:C5   |
 304     | 6 7   8 9 ||2:GND |7:LCM  |C:?    |H:C4   |
 305     | A       B ||3:Out |8:S2   |D:C6   |I:C3   |
 306     | C D   E F ||4:STR |9:S1   |E:C0   |J:C2   |
 307     | G H I J K ||5:VCC |A:C7   |F:?    |K:C1   |
 308     +-----------++------+-------+-------+-------+
 309
 310     8048            Sensor
 311     D0-2 ====/===== S0-2
 312     D3   ---------- STR
 313            7917 buffer
 314     D4   --|>--+--- OUT
 315     T0   ------'
 316
 317     Speculation: 8048:D4 is used to prepare to sense capacitance.(charge key capcitor?)
 318
 319 Procedure:
 320     at 030dh:
 321     D0-2=<column>   ; select column S0-2
 322     D4=1            ; Prepare sensor(Charge?)
 323     P1/P2=<row>     ; select row
 324     D0-4=<default>  ; 00010(bus=c2h)
 325     D3=1            ; Strobe
 326     P1/P2=0         ; unselect row
 327     read T0         ; see key state
 328
 329     at 01afh:
 330     D0-2=<column>
 331     D4=1
 332     D0-2=2(010)     ; select col2
 333     P2=01h          ; select row
 334     D3=1            ; Strobe
 335     P2=00h          ; unselect row
 336     read T0
 337
 338
 339 Keyswitch Matrix
 340 ----------------
 341 6019284(62-key):
 342      |0       1       2       3       4       5       6       7
 343     -|--------------------------------------------------------------
 344     0|Enter   RShift  JIS_    PD3     PD2     \|      LofBS   BS
 345     1|RAlt    RBlank  /?      '"      {}      Cent!   -       =
 346     2|,       .       l       ;       o       p       9       0
 347     3|m       n       k       j       u       i       7       8
 348     4|Spc     b       g       h       t       y       5       6
 349     5|v       c       d       f       e       r       3       4
 350     6|LAlt    z       x       s       a       w       q       2
 351     7|Reset   LBlank  ISO\    LShift  CapLock PD1     `~      1
 352     8|_       x       _       _       x       x       _       _ (Identity bits: 32h)
 353
 354     Two 15-line flat cables shown from bttom of PCB:
 355
 356           Flatcable A    Flatcable B
 357         /             \/             \
 358         0123456789ABCDE0123456789ABCDE
 359         --8-----01234567----76543210--
 360           Id    row         col         -:GND
 361
 362
 363 Keyboard Identity Bits
 364 ----------------------
 365 4704 keyboards has its identity bit marks on PCB matrix and it is readable
 366 from firmware so that it can select key layout depending on this.
 367
 368 PCB pictures:
 369     Model 100:
 370         http://kishy.dyndns.org/wp-content/uploads/2013/02/6019273_0011.jpg
 371     Model 200:
 372         http://kishy.dyndns.org/wp-content/uploads/2013/02/6019284_0020_capacitive-pcb-top.jpg
 373     Model 300:
 374         http://kbtalking.cool3c.com/article/23272
 375     Model 400:
 376         http://kishy.dyndns.org/wp-content/uploads/2011/09/6020218_distrib_0019.jpg
 377
 378
 379
 380 4704 Firmware
 381 =============
 382
 383 Startup sequence
 384 ----------------
 385 Power on Reset(0000h):
 386     Short Buzzer
 387         turns Buzzer(BZ=L) on at 0002h
 388         turns Buzzer(BZ=H) off at 01adh
 389     Initialize all memory(3fh-00h)
 390     Initialize other registers
 391     Read keyboard id and set default parameter at 01afh
 392         set break flag for Alt key by default
 393     Test and clear memory(3fh..00h) at 0202h
 394     Test program memory at 0214h
 395     r4=($21&07h)|50h at 0020h
 396     Send test result at 022dh
 397         sends [a0h | (keyboard id&f0h)>>4] on success
 398         6019284 seneds a3h on success
 399     Wait for data from host - it expects FC command data followed by ffh(end)
 400     Main loop
 401
 402 Soft Reset(0008h):
 403     Initialize all memory(20h-00h) It retains parameter memory.
 404     Initialize other registers
 405     r4=($21&07h)|50h at 0020h
 406     Main loop
 407
 408
 409 Memory Map
 410 ----------
 411 RAM(64 bytes):
 412 $01-07  *Bank0* Registers r0-r7
 413         r0  temporary use
 414         r1  temporary use
 415         r2  temporary use
 416         r3  row mask of scan 024dh, 0257h
 417         r4  bus default value
 418             7 6 5 4 3 2 1 0
 419             | | | | | | | |
 420             | | | | | `-`-`------ Sensor column select
 421             | | | | `------------ Sensor strobe?
 422             | | | `-------------- Sensor column set?
 423             | | `---------------- Data
 424             | `------------------ Clock
 425             `-------------------- Buzzer control(L:on/H:off)023ch
 426             =$21&07h|50h: call 0020h at 001ch soft reset (52h=0101 0010)
 427             =$21&07h|50h: call 0020h at 0109h command FC (52h=0101 0010)
 428             =r4|80h: at 00f4h(FD command)
 429             =r4&7fh: at 023ch(Main)
 430             =r4&f0h: at 0200h
 431         r5  repeat dealy/interval
 432             used at 02d7h
 433             =07h at 02d9h
 434             =28h at 02ddh
 435             =28h at 02e1h
 436        *r6  0bh at 00edh(FD command)
 437             used at 0232h
 438         r7  received data from host
 439             temporary use at 01afh
 440             temporary use at 005dh
 441             =r4&c0h(current bus value?) 0247h
 442 $08-17  8-level stack(2*8)
 443     $0E
 444     :       last key state(1:pressed/0:released)
 445     $15     (0E-15)=8*8=64 matrix(for 50-key and 62-key?)
 446     $16
 447     :       last key state(1:pressed/0:released)
 448     $1C     (16-1C)=7*8=56 (extension for 77-key?)
 449
 450 $18-1F  *Bank1* Registers 0-r7
 451     Outgoing buffer of data sent to host
 452     $1D     r5      outgoing buffer top
 453     $1E     r6      outgoing buffer
 454     $1F     r7      outgoing buffer bottom
 455
 456
 457 $20     Resend buffer: code last sent used by 'Resend'(FE)
 458
 459 $21     Keyboard identity bits
 460         0011 0010  (6019284: 32h read from Row(I))
 461          ||| ||||
 462          ||| |```- Sensor chip control(bus value)??
 463          ||| `---- ???
 464          ```------ keyboard model id
 465
 466         set at 01fah on Power on Reset:  32h from row8(I)(6019284)
 467         got at 0020h on Soft Reset:
 468         got at 034eh on translate into scan code:
 469         got at 0125h on command FC:
 470         set from scan 8(I) row at 01fdh
 471
 472         Keyboard model id:
 473             Model 100 6019273 50-key (grid layout):     22h(from picture)
 474             Model 200 6019284 62-key Alpha(60% layout): 32h
 475             Model 300 6019303 77-key Expanded Alpha:    42h?(from dump list)
 476             Model 400 6020218 107-key Full key:         no identity
 477                 Looks like this firmware does not support 107-key.
 478
 479         IBM 4704 keyboards:
 480             It seems Model 100, 200 and 300 keyboards share one firmware code and
 481             have small square copper patterns on righ side of PCB to identify
 482             its layout. See following pictures. Model 400 may use another firmware.
 483
 484 $22-3F  30-byte Parameter RAM(Repeat and Break flags)
 485         Parameter byte is comprised of four flag pairs. Flags occupies two bits each a key.
 486         Parameter RAM can have flags for 120(4*30) keys.
 487
 488         Parameter byte and flags:
 489             bit 7   6   5   4   3   2   1   0
 490                 3r  3b  2r  2b  1r  1b  0r  0b
 491 :
 492 $3F     End of Memory(64 bytes)
 493
 494
 495
 496
 497 Entry points
 498 ------------
 499 0020    Soft Reset  r4=($21&07h)|50h = (32h&07h)|50h=52h
 500 0029    r1=r1+(a), a=r0 (page 0)
 501 002c    (F0=0: send or receive data with 'interpret command mode')
 502 002d    Receive data or Send scan code
 503 0035    Send scan code
 504         return: F1=1
 505 0082    Receive data from host
 506         condition: F0==0   interpret command
 507                    F0==1   return receive data(a)
 508         return:    F1=1(ERROR) 00c7 (Receive ACK/Parity Error) 00b6,00ce
 509                    F1=0?
 510                    a=recieve data, (with F0=0 00dc) F0==0 means 'data received'
 511 00bc    push 7f(error) into outgoing buffer
 512 00be    push data/response into outgoing buffer(r5,r6,r7)
 513 00d2    interpret keyboard command
 514 00de    calculate parity
 515
 516 01a4    r1=r1+(a), a=r0 (page 1)
 517 01a5    r1=r1+a, a=r0
 518 01a9    Buzzer and Scan row8(*) and set param: call from Power on Reset 0018h
 519 01af    Read keyboard identity bits from row8(I) and set param: - call from command FC 0107h
 520 0202    Memory Test(Power on Reset)
 521
 522 0230    Main loop:  send, receive data and scan
 523         send/receive: call 002c
 524 0263    **Scan matrix**(F1==0): F1=1, r1=15h, r2=3fh, r3=01h
 525 0287    **Scan matrix**(F1==1): F1=0, r1=1ch, r2=77h, r3=02h
 526 0325    get key configure flags(a=-----rb; where r:repeat enable, b:break enable)
 527 0339    queue data at bottom of outgoing buffer
 528 034e    translate into scan code
 529         scan code table1/table2
 530
 531
 532 Keyboard command entry points
 533 -----------------------------
 534 FF: jump_table0   Soft Reset(008h)
 535 FE: jump_table1   Resend(return content of $20)
 536 FD: jump_table2   Short beep BZ
 537 FC: jump_table3   parameter configuration(100h)
 538 FB: jump_table4   Soft Reset(008h)
 539 FA: jump_table5   Reset(000h)
 540
 541
 542
 543
 544 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 545 ;
 546 ;  8048 Disassembly of IBM 6019284 ROM dump
 547 ;
 548 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 549 ; label mnemonic                ; address   comment
 550 ;-------------------------------------------------------------------------------------
 551         org     000h
 552 ; jump_table:5  Hard Reset/Power on Reset
 553         mov     a,#07fh         ; 0000 - a=7f        Power on Reset
 554         outl    bus,a           ; 0002 - BZ=L(off), others=H
 555         mov     r0,#03fh        ; 0003 - r0=3fh
 556         clr     f1              ; 0005 - F1=0
 557         jmp     X000c           ; 0006 -
 558 ; jump_table:0,4 Soft Reset
 559         mov     r0,#020h        ; 0008 - r0=20h      $20=resend buffer
 560         clr     f1              ; 000a -
 561         cpl     f1              ; 000b - F1=1
 562
 563 ;;;;;;;;;;;;;;;;;;
 564 ;   initialize memory
 565 ;       hard reset  clear 3f-00h    F1=0
 566 ;       soft reset  clear 20-00h    F1=1
 567 X000c:  clr     f0              ; 000c - F0=0
 568         clr     a               ; 000d - a=0
 569 X000e:  mov     @r0,a           ; 000e - @r0=0   r0=$3f(hard)/$20(soft)
 570         djnz    r0,X000e        ; 000f - clear RAM 3f/20h to $00
 571         mov     psw,a           ; 0011 - psw=0
 572         outl    p1,a            ; 0012 - p1=0
 573         outl    p2,a            ; 0013 - p2=0
 574         dis     tcnti           ; 0014 - disable timer overflow
 575         dis     i               ; 0015 - disable INT
 576         jf1     X001c           ; 0016 - jump if F1==1(Soft Reset?)
 577
 578 ; F1==0 Power on Reset
 579         call    X01a9           ; 0018 - read keyboard id and set default parameter
 580         jmp     X0202           ; 001a - Memory Test and go to Main
 581
 582 ; F1==1 Soft Reset
 583 X001c:  call    X0020           ; 001c - ; r4=$21&07h|50h(52h?), a=r4
 584         jmp     X0230           ; 001e - ; go to Main
 585
 586 ;;;;;;;;;;;;;;;;;;
 587 ; Set r4
 588 : INPUT:    r4???
 589 : RETURN:   a=r4(original)
 590 ;           r4=$21&07h|50h
 591 ;
 592 X0020:  mov     r0,#021h        ; 0020 -  r0=21h(keyboad identity bits)
 593         mov     a,@r0           ; 0022 -  a=($21)
 594         anl     a,#007h         ; 0023 -  a=a&07h
 595         orl     a,#050h         ; 0025 -  a=a|50h
 596         xch     a,r4            ; 0027 -  swap a,r4
 597         ret                     ; 0028 -
 598
 599 ; read program memory @page0
 600 ; INPUT: a:address
 601 ; OUTPUT: a=(a)@page0
 602 X0029:  movp    a,@a            ; 0029 -
 603         jmp     X01a5           ; 002a - r1=r1+a, a=r0
 604
 605
 606
 607 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 608 ;
 609 ; Receive data or Send scan code
 610 ; INPUT:    F0=0:interpret command/1:retern data            used in Receive command/data
 611 ; OUTPUT:   F0=0(received)/1(not received)
 612 ; DONE: a=0, F1=1, buffer rotate
 613 X002c:  clr     f0              ; 002c - F0=0
 614 X002d:  jnt1    X0082           ; 002d - go to receive if T1(CLK)==L
 615         sel     rb1             ; 002f - switch to bank1
 616         mov     a,r5            ; 0030 - a=r5(bank1)            r5(bank1): scan code buffer
 617         sel     rb0             ; 0031 - switch to bank0
 618         jnz     X0035           ; 0032 - jump if r5(bank1)!=0
 619         retr                    ; 0034 - return if r5(bank1)==0 buffer empty
 620
 621 ;;;;;;;;;;;;;;;;;;
 622 ; Send scan code
 623 ; INPUT:    a=data
 624 ; OUTPUT:   F1=1:Sent,Rotate,Data ready/0:???
 625 X0035:  dec     a               ; 0035 - a--
 626         clr     c               ; 0036 - c=0
 627         call    X00de           ; 0037 - c=parity calc
 628         jnt1    X0082           ; 0039 - go to receive if T1(CLK)=L
 629 ; Start bit
 630         anl     bus,#0bfh       ; 003b - [CLK=L]
 631         orl     bus,#020h       ; 003d - [DATA=H]        [[[Start bit]]]
 632         mov     r0,#010h        ; 003f - r0=10h
 633
 634
 635 ; check inhibited(DATA==L) - check DATA line released by host
 636 X0041:  jni     X0047           ; 0041 - jump if DATA==L LOOP>
 637         jni     X0049           ; 0043 - jump if DATA==L
 638         jmp     X0054           ; 0045 - cont. if DATA==H
 639 X0047:  jmp     X0049           ; 0047 -
 640 X0049:  djnz    r0,X0041        ; 0049 - <LOOP  timeout?
 641 ; time out - end
 642         orl     bus,#040h       ; 004b - [CLK=H]
 643         anl     bus,#0dfh       ; 004d - [DATA=L]       [[[idle state]]]
 644         retr                    ; 004f - return send end(give up with inhibited)
 645
 646
 647 ; check data==7eh   Keep data in 'Resend' buffer unless it is 7eh
 648 X0050:  xrl     a,#07eh         ; 0050 - revert a
 649         jmp     X005d           ; 0052 -
 650
 651 X0054:  mov     r0,#020h        ; 0054 - r0=20h 'Resend' Buffer
 652         xrl     a,#07eh         ; 0056 - a=a^7eh(0111 1110)
 653         jz      X0050           ; 0058 - jump if a==7eh
 654 ; a!=7eh        retain data to $20(resend buffer) if data is not 7eh
 655         xrl     a,#07eh         ; 005a - revert a
 656         mov     @r0,a           ; 005c - $20=a  retain a to 'Resend' buffer
 657
 658
 659 ; Data bit0-7 and Parity(c)
 660 ; Pulse H:18/L:9??
 661 X005d:  mov     r7,#009h        ; 005d - r7=9
 662 X005f:  mov     r0,#009h        ; 005f - r0=9 LOOP>>
 663         jb0     X0069           ; 0061 - jump if a:bit0==1
 664 ; a:bit0==0
 665 ; send DATA=0
 666         anl     bus,#0dfh       ; 0063 - [DATA=L]
 667         orl     bus,#040h       ; 0065 - [CLK=H]
 668         jmp     X006f           ; 0067 -
 669 ; a:bit0==1
 670 ; send DATA=1
 671 X0069:  orl     bus,#020h       ; 0069 - [DATA=H]
 672         orl     bus,#040h       ; 006b - [CLK=H]
 673         jmp     X006f           ; 006d -
 674 ; hold CLK=H
 675 X006f:  djnz    r0,X006f        ; 006f - 9*2cycle delay (around 60us??)
 676         anl     bus,#0bfh       ; 0071 - [CLK=L]
 677         rrc     a               ; 0073 - a=a>>1, c=a:bit0
 678         djnz    r7,X005f        ; 0074 - <<LOOP
 679 ; Stop bit
 680 ; a=0, F1=1, buffer rotate
 681         anl     bus,#0dfh       ; 0076 - [DATA=L]           [Idle]  End
 682         clr     a               ; 0078 - a=0
 683         clr     f1              ; 0079 -
 684         cpl     f1              ; 007a - F1=1               [Sent?]
 685         orl     bus,#040h       ; 007b - [CLK=H]            [Idle]  End
 686 ; remove from outgoing buffer: r7=0, r6=r7, r5=r6
 687         sel     rb1             ; 007d - switch to bank1
 688         xch     a,r7            ; 007e -
 689         xch     a,r6            ; 007f -
 690         xch     a,r5            ; 0080 - 0->r7->r6->r5->a  [Bank1 Buffer rotate]
 691         retr                    ; 0081 - retr reverts to bank0
 692
 693
 694
 695 ;;;;;;;;;;;;;;;;;;
 696 ; Receive command/data from host
 697 ; INPUT:    F0=0:interpret command/1:return data(used by command)
 698 ; OUTPUT:   F0=0(received)/1(not received)
 699 ;           F1=1:Error/0:OK
 700 ; a: data
 701 ; c: parity
 702 ; F1: 0: Receive or Send 1: Receive
 703 ;
 704 X0082:  jf1     X0086           ; 0082 -  jump if F1==1
 705 ; F1==0
 706         jmp     X002d           ; 0084 -  Can't recevie, do 'Receive or Send' again
 707 ; F1==1
 708 X0086:  mov     r0,#006h        ; 0086 -  r0=6h
 709 X0088:  djnz    r0,X0088        ; 0088 -  6*2cycle dealy
 710         jt1     X00cb           ; 008a -  return if T1(CLK)==H
 711         anl     bus,#0bfh       ; 008c -  [CLK=L]
 712         orl     bus,#020h       ; 008e -  [DATA=H]                  [Start bit]
 713         mov     r0,#011h        ; 0090 -
 714 X0092:  djnz    r0,X0092        ; 0092 -  11*2cycle delay
 715         mov     r7,#009h        ; 0094 -  r7=9h
 716 X0096:  orl     bus,#040h       ; 0096 -  LOOP>[CLK=H]              [Clock up for receive]
 717         mov     r0,#008h        ; 0098 -
 718 X009a:  djnz    r0,X009a        ; 009a -  8*2cycle delay
 719         anl     bus,#0bfh       ; 009c -  [CLK=L]                   [Clock down]
 720         jni     X00a9           ; 009e -  jump if INT(DATA)==L      [Read bit] Read twice for debounce?
 721 ; DATA==H
 722         orl     a,#001h         ; 00a0 -  a:bit0=1
 723         jni     X00ad           ; 00a2 -  jump if INT(DATA)==L
 724 ; DATA==H
 725 X00a4:  rrc     a               ; 00a4 -  a=a>>1 with carry         [Next bit]
 726         djnz    r7,X0096        ; 00a5 -  <LOOP
 727         jmp     X00b0           ; 00a7 -                            [go to Stop]
 728 ; DATA==L
 729 X00a9:  anl     a,#0feh         ; 00a9 - a:bit0=0
 730         jni     X00a4           ; 00ab -  jump if INT(DATA)==L
 731 ; DATA==H
 732 X00ad:  clr     f1              ; 00ad -  F1=0                      [Receive Error]
 733         jmp     X00a4           ; 00ae -
 734
 735
 736 ; wait for Stop/ACK (DATA=H)
 737 ; F0: 0=jump table, 1=return(with F0=0)
 738 X00b0:  orl     bus,#040h       ; 00b0 - [CLK=H]                    [Idle] End
 739         mov     r0,#004h        ; 00b2 -
 740 X00b4:  djnz    r0,X00b4        ; 00b4 - 4*2cycle? 8*0.2us=1.6us?
 741         jni     X00c7           ; 00b6 - jump if INT(DATA)==L       [Stop Error] *no error response?
 742 ; DATA==H
 743         anl     bus,#0dfh       ; 00b8 - [DATA=L]                   [Idle] End
 744         jf1     X00cc           ; 00ba - jump if F1==1
 745 ; F1==0                                                             [Receive Error]
 746
 747
 748 ; push 7eh into outgoing buffer (Receive Error at 00bah/Parity Error at 00ceh)
 749 X00bc:  mov     a,#07eh         ; 00bc - 7eh: error response
 750
 751 ; push data into top of outgoing buffer(Error response)
 752 ; a:data
 753 ; r5=a, r6=r5, r7=r6
 754 X00be:  sel     rb1             ; 00be - switch to bank1
 755         inc     a               ; 00bf - a++
 756         xch     a,r5            ; 00c0 - a->r5->r6->r7->a
 757         xch     a,r6            ; 00c1 -
 758         xch     a,r7            ; 00c2 -
 759         jz      X00cb           ; 00c3 - jump if a==0
 760         mov     r7,#0ffh        ; 00c5 - r7=ffh overflow            [Over flow:FE]
 761
 762 X00c7:  anl     bus,#0dfh       ; 00c7 - [DATA=L]                   [Idle] End
 763         clr     f1              ; 00c9 -
 764         cpl     f1              ; 00ca - F1=1                       [Error flag]
 765 X00cb:  retr                    ; 00cb -
 766
 767
 768
 769 ; check parity of recieve data
 770 ; F1==1
 771 X00cc:  call    X00de           ; 00cc - call parity calc
 772         jc      X00bc           ; 00ce - jump if carryflag=1    (Parity ERROR)
 773 ; parity OK
 774         jf0     X00dc           ; 00d0 - jump if F0==1
 775
 776
 777 ;;;;;;;;;;;;;;;;;
 778 ; F0==0
 779 ; Interpret command
 780 ;
 781         cpl     a               ; 00d2 - compliment a       ffh-a(command)
 782         add     a,#jump_table   ; 00d3 - a=a+#jump_table
 783         jc      X00d8           ; 00d5 -
 784         jmpp    @a              ; 00d7 - jump table             [Keyboard command]
 785 ; Command Out bound Error
 786 X00d8:  mov     a,#0fdh         ; 00d8 -    error response: FD
 787         jmp     X00be           ; 00da -
 788
 789 ;;;;;;;;;;;;;;;;;
 790 ; F0==1
 791 ; Return data
 792 X00dc:  cpl     f0              ; 00dc - F0=~F0(=0)
 793         ret                     ; 00dd -
 794 ;
 795 ; recieve data/command
 796 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 797
 798
 799 ;;;;;;;;;;;;;;;;;;
 800 ; calculate parity: 'c' depends on number of '1' in 'a'
 801 ;   INPUT: a=data
 802 ;   OUTPUT: c(carry flag)
 803 X00de:  mov     r0,#008h        ; 00de - b8 08  8.  r0=8h
 804 X00e0:  rr      a               ; 00e0 - 77     w   a=a>>1
 805         jb0     X00e4           ; 00e1 - 12 e4  .d  jump if a:bit0==1
 806         cpl     c               ; 00e3 - a7     '   compliment carry flag
 807 X00e4:  djnz    r0,X00e0        ; 00e4 - e8 e0  h`  jump if --r0!=0
 808         cpl     c               ; 00e6 - a7     '
 809         ret                     ; 00e7 - 83     .
 810
 811
 812
 813 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 814 ;
 815 ; Keyboard command  jump table
 816 ;
 817 ; jump_table:1 FE   Resend(return content of $20)
 818 X00e8:  mov     r0,#020h        ; 00e8 -  $20
 819         mov     a,@r0           ; 00ea -  a=$20 get from resend buffer
 820         jmp     X00be           ; 00eb -  push into outogoing buffer
 821
 822 ; jump_table:2 FD   r6=0bh, r4=r4|80h
 823         mov     r6,#00bh        ; 00ed -  r6=0bh  BZ duration(scan cycles)?
 824         orl     bus,#080h       ; 00ef -  BZ=H(on)
 825         mov     a,r4            ; 00f1 -
 826         orl     a,#080h         ; 00f2 -  BZ=H
 827         mov     r4,a            ; 00f4 -  r4=r4|80h BZ=H(on) bus-default
 828         retr                    ; 00f5 -
 829
 830 ; jump_table:3 FC
 831         mov     r1,#01eh        ; 00f6 -  r1=1eh
 832         jmp     X0100           ; 00f8 -
 833
 834 ;
 835 ; keyboard commands:
 836 ;
 837 ; FF: jump_table0   Soft Reset(008h)
 838 ; FE: jump_table1   Resend(return content of $20)
 839 ; FD: jump_table2   BZ set BZ=H(on) to bus and r4(bus-default), duration to r6
 840 ; FC: jump_table3   Set key configuration
 841 ; FB: jump_table4   Soft Reset(008h)
 842 ; FA: jump_table5   Reset(000h)
 843 ;
 844 jump_table:     db      008h,0e8h,0edh,0f6h,008h,000h           ; 00fa .hmv..
 845 ;
 846 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 847
 848
 849
 850 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 851 ;
 852 ; command FC    parameter configuration
 853 ;   clear $22-3f, then set data received from host
 854 ;
 855 ; r4:
 856 ;   set to $21&07h|50h
 857 ; r7: received data
 858 ;   r7=data|7fh
 859 ;       F0=0 if data:bit7=1
 860 ;       F0=1 if data:bit7=0
 861 ;
 862 ; data received(r7):
 863 ;   FF      End(0114h)
 864 ;   FE      Resend and receive again(011ah)
 865 ;   FF-80   F0=0    if bit7 of r7 is set
 866 ;   7F-00   F0=1    if bit7 of r7 is reset
 867 ;
 868 ;
 869
 870 ;;;;;;;;;;;;;;;;;;
 871 ; clear parameter configuration RAM $3f..22
 872 ; INPUT: r1=1eh=30
 873 ;   called at 00f6h
 874 X0100:  clr     a               ; 0100 - a=0
 875         mov     r0,#03fh        ; 0101 - r0=3f
 876 X0103:  mov     @r0,a           ; 0103 - $3f=a
 877         dec     r0              ; 0104 - r0--
 878         djnz    r1,X0103        ; 0105 -
 879         call    X01af           ; 0107 - Read keyboar id and set parameter flags
 880         call    X0020           ; 0109 - r4=($21 & 07h | 50h) =52h
 881
 882 ;;;;;;;;;;;;;;;;;;
 883 ; data receive from host
 884 ;
 885 X010b:  clr     f0              ; 010b - LOOP>>
 886         cpl     f0              ; 010c - F0=1
 887 X010d:  call    X002d           ; 010d - receive/send data with F0=1
 888         jf0     X010d           ; 010f - LOOP while F0==1
 889
 890
 891 ; received data from host(F0==0)
 892         mov     r7,a            ; 0111 - r7=data received
 893         cpl     c               ; 0112 - c=~c
 894         cpl     a               ; 0113 - a=~a
 895
 896 ;;;;;;;;;;;;;;;;;
 897 ; a==FF *End*
 898         jz      X013b           ; 0114 - return if a==FF
 899         xrl     a,#001h         ; 0116 -
 900         jnz     X011e           ; 0118 - jump if a!=FE
 901
 902 ;;;;;;;;;;;;;;;;;
 903 ; a==FE *Resend*
 904         call    X00e8           ; 011a - Resend         and continue...
 905         jmp     X010b           ; 011c - <<LOOP         Send/Receive loop again
 906
 907 ;;;;;;;;;;;;;;;;;
 908 ; else  *Set flag*
 909 ;   data:bit7=1:enable break/0:enable repeat
 910 X011e:  mov     a,r7            ; 011e - a=r7(data received)
 911         jb7     X0122           ; 011f - jump if a:bit7==1  (1xxx xxxx)
 912         cpl     f0              ; 0121 - F0=~F0=1   if a:bit7==0    [F0=1 means data:bit7==0]
 913 X0122:  anl     a,#07fh         ; 0122 - a=a&7fh                    [data:bit6-0=scan code]
 914         mov     r7,a            ; 0124 - r7=a
 915
 916
 917 ; identify keybaord from $21=keyboar identity bits
 918         mov     r1,#021h        ; 0125 - r1=21h
 919         mov     a,@r1           ; 0127 - a=($21)
 920         anl     a,#0f0h         ; 0128 - a=a&f0h
 921         xrl     a,#020h         ; 012a - a=a^20h
 922         jz      X013c           ; 012c - jump if $21==0010 xxxx     6019273 50-key?
 923         xrl     a,#010h         ; 012e - a=a^10h
 924         jz      X0142           ; 0130 - jump if $21==0011 xxxx     *6019284 62-key*
 925         xrl     a,#070h         ; 0132 - a=a^70h
 926         jz      X0148           ; 0134 - jump if $21==0100 xxxx     6019303 77-key?
 927
 928 ; Unknown keyboard
 929         mov     a,r7            ; 0136 - a=r7(received data)
 930         call    X015f           ; 0137 -                                [Set flag]
 931         jmp     X010b           ; 0139 - <<LOOP receive again
 932
 933 ; End
 934 X013b:  retr                    ; 013b -
 935
 936
 937
 938 ; Set 'index' and 'size' scan code table for each keyboard model
 939 ;   r1: end of scan code table(index)
 940 ;   r2: number of scan code table(size)
 941 ; 6019273 50-key?
 942 X013c:  mov     r1,#0afh        ; 013c - r1=afh     address@page3   03afh(table1)
 943         mov     r2,#038h        ; 013e - r2=38h     0011 10(00)     56keys
 944         jmp     X014c           ; 0140 -
 945
 946 ; *6019284 62-key*
 947 X0142:  mov     r1,#0efh        ; 0142 - r1=efh     address@page3   03efh(table2)
 948         mov     r2,#040h        ; 0144 - r2=40h     0100 00(00)     64keys
 949         jmp     X014c           ; 0146 -
 950
 951 ; 6019303 77-key?
 952 X0148:  mov     r1,#0ffh        ; 0148 - r1=ffh     address@page3   03ffh(table2)
 953         mov     r2,#050h        ; 014a - r2=50h     0101 00(00)     80keys
 954
 955
 956
 957 ; get scancode from table and test loop
 958 LOOP>>
 959 X014c:  mov     a,r1            ; 014c - a=r1
 960         movp3   a,@a            ; 014d - a=(r1)     read scan code table
 961         xrl     a,r7            ; 014e - a=a^r7     a==r7(received scan code)
 962         jnz     X0156           ; 014f -
 963
 964 ; scan code(a) == received data(r7)
 965         dec     r2              ; 0151 - r2--
 966         mov     a,r2            ; 0152 - a=r2
 967         call    X015f           ; 0153 - call                           [Set flag]
 968         inc     r2              ; 0155 - r2++
 969
 970 ; check next scan code
 971 X0156:  dec     r1              ; 0156 - r1--               r1: address of table
 972         djnz    r2,X014c        ; 0157 - <<LOOP while --r2  r2: number of table
 973
 974         jnc     X015d           ; 0159 - jump if r1>=0
 975         call    X00d8           ; 015b - Error: FD and cont.            [Out of bound Error: FD]
 976 X015d:  jmp     X010b           ; 015d - <<LOOP Receive next data
 977 ;;;
 978
 979
 980 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 981 ; Set flag routine
 982 ;
 983 ; INPUT: a=table index(number of table)
 984 ;        a: AAAA AAFF(AAAAAA:index of parameter RAM, FF: flag position(0-3))
 985 ;
 986 X015f:  clr     c               ; 015f - c=0
 987                                 ; calculate RAM address
 988         mov     r2,a            ; 0160 - r2=a       r2=data
 989         rr      a               ; 0161 - a=a>>1
 990         rr      a               ; 0162 - a=a>>1     a/4(four keys per a parameter byte)
 991         add     a,#022h         ; 0163 - a=a+22h    start of parameter bytes
 992         mov     r0,a            ; 0165 - r0=a       r0=parameter address
 993
 994         mov     a,r2            ; 0166 - a=r2
 995         anl     a,#003h         ; 0167 - a=a&03h            [a=flag position]
 996         jz      X017e           ; 0169 - if FF==0b00
 997         dec     a               ; 016b - a--
 998         jz      X018a           ; 016c - if FF==0b01
 999         dec     a               ; 016e - a--
1000         jz      X0197           ; 016f - if FF==0b10
1001
1002 ;
1003 ; Parameter byte and configure flags
1004 ;   bit 7   6   5   4   3   2   1   0
1005 ;       3r  3b  2r  2b  1r  1b  0r  0b
1006
1007 ;;;;;;;;;;;;;;;;;;
1008 ; FF==11b:  3r/3b
1009         mov     a,@r0           ; 0171 - a=(r0)             r0=parameter address
1010         anl     a,#03fh         ; 0172 - a=a&0011 1111b     clear 3r/3b
1011         jf0     X017a           ; 0174 - jump if F0==1
1012 ; F0==0(received data:bit7==1)
1013 ; a=a|40h
1014         orl     a,#040h         ; 0176 - a=a|0100 0000b     3b: break enabled
1015
1016
1017
1018 ;;;;;;;;;;;;;;;;;;
1019 ; store to RAM and return
1020 X0178:  mov     @r0,a           ; 0178 - (r0)=a store parameter to RAM
1021         ret                     ; 0179 - return a: command/received data
1022 ; End of Set flag
1023 ;;;;;;;;;;;;;;;;;;
1024
1025
1026
1027 ; F0==1 (data:bit7==0)
1028 ; a=a|80h
1029 X017a:  orl     a,#080h         ; 017a - a=a|1000 0000b     3r: repeat enabled
1030         jmp     X0178           ; 017c -
1031 ;;;
1032
1033
1034 ;;;;;;;;;;;;;;;;;;
1035 ; FF==00b:  0r/0b
1036 X017e:  mov     a,@r0           ; 017e - a=(r0)
1037         anl     a,#0fch         ; 017f - a=a & 1111 1100b   clear 0r/0b
1038         jf0     X0186           ; 0181 - jump if F0==1
1039 ; F0==0(data:bit==1)
1040         inc     a               ; 0183 - a++                0b: break enabled
1041         jmp     X0178           ; 0184 -
1042 ; F0==1(data:bit==0)
1043 X0186:  orl     a,#002h         ; 0186 -                    0r: repeat enabled
1044         jmp     X0178           ; 0188 -
1045 ;;;
1046
1047
1048 ;;;;;;;;;;;;;;;;;;
1049 ; FF==01b:  1r/1b
1050 X018a:  mov     a,@r0           ; 018a -
1051         anl     a,#0f3h         ; 018b -                    clear 1r/1b
1052         jf0     X0193           ; 018d -
1053 ; F0==0(data:bit==1)
1054         orl     a,#004h         ; 018f -                    1b: break enabled
1055         jmp     X0178           ; 0191 -
1056 ; F0==1(data:bit==0)
1057 X0193:  orl     a,#008h         ; 0193 -                    1r: repeat enabled
1058         jmp     X0178           ; 0195 -
1059 ;;;
1060
1061
1062 ;;;;;;;;
1063 ; FF==10b   parameter|10h / parameter|20h
1064 X0197:  mov     a,@r0           ; 0197 -
1065         anl     a,#0cfh         ; 0198 -                    clear 2r/2b
1066         jf0     X01a0           ; 019a -
1067 ; F0==0(data:bit==1)
1068         orl     a,#010h         ; 019c -                    2b: break enabled
1069         jmp     X0178           ; 019e -
1070 ; F0==1(data:bit==0)
1071 X01a0:  orl     a,#020h         ; 01a0 -                    2r: repeat enabled
1072         jmp     X0178           ; 01a2 -
1073 ;;;
1074
1075
1076 ;
1077 ; End of command FC
1078 ;
1079 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1080
1081
1082
1083 ;;;;;;;;;;;;;;;;;;
1084 ; read program memory @page1
1085 ;   INPUT: a=address of program memory
1086 X01a4:  movp    a,@a            ; 01a4 - a=(a)@page1
1087
1088 ;   OUTPUT: r1=r1+a, a=r0
1089 ; r1=r1+a,a=r0
1090 X01a5:  add     a,r1            ; 01a5 -
1091         mov     r1,a            ; 01a6 - r1=a+r1
1092         mov     a,r0            ; 01a7 - a=r0
1093         ret                     ; 01a8 -
1094
1095
1096
1097 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1098 ;
1099 ; Scan row8(I) and set parameter flags(on Power on Reset)
1100 ;
1101 ; call from hard reset 0018h with a=0, r0=0, r1=0?
1102 ;   INPUT: r0, r1: for wait loop
1103 ;   OUTPUT: $21=keybaord identity bits, r4=$21&f0h
1104 ;
1105
1106 ;;;;;;;;;;;;;;;;;;
1107 ; delay to make Buzzer audible when powering up??
1108 X01a9:  djnz    r0,X01a9        ; 01a9 - r0*2cycle
1109         djnz    r1,X01a9        ; 01ab - r1*(r0*2cycle+2cycle) 256*(256*2+2)=131584(2us?/cycle) around 260ms??
1110         anl     bus,#0c0h       ; 01ad - BZ=_,CLK=_,DATA=L  line is idle
1111
1112
1113 ;;;;;;;;;;;;;;;;;;
1114 ;
1115 ; Read keyboard identity bits from row8(I) and set parameter flags(on command FC)
1116 ;   INPUT: a=0
1117 ;   OUTPUT: r4=a=scanned data of row8(I)=keyboard identity bits
1118 ;
1119 ;   F0: 1:read(frist)/0:read(second)&settle
1120 ;        It needs to read same value twice to settle.
1121 ;
1122 ;   Keyboar id bit pattern on PCB:
1123 ;       mark:       1
1124 ;       brank:      0
1125 ;   Sensor value meaning:
1126 ;       Sensor:     0           1
1127 ;       Kbd id:     1(mark)     0(blank)
1128 ;       Key:        1(pressed)  0(released)
1129 ;
1130 ; called from command FC 0107h
1131 X01af:  mov     r7,#008h        ; 01af - r7=08h                 [column]
1132 X01b1:  rl      a               ; 01b1 - a=a<<1 LOOP_0{         [next column]
1133 X01b2:  mov     r4,a            ; 01b2 - LOOP{  r4=a            [data]
1134         cpl     f0              ; 01b3 - F0=~F0     toggle F0   [read twice to debounce]
1135         mov     a,r7            ; 01b4 - a=r7
1136         dec     a               ; 01b5 - a--
1137         orl     a,#0c0h         ; 01b6 - col(7-0)|c0h = c7-c0h  BZ=H:on [Beep during FC command]
1138         outl    bus,a           ; 01b8 -                        [Select column]
1139         orl     bus,#010h       ; 01b9 - D4=1                   [charge sensor out=H?]
1140         mov     a,#0d2h         ; 01bb - 1101 0010
1141         outl    bus,a           ; 01bd - bus=d2h   D4-0=10010   select column 2?
1142
1143 ;
1144         orl     p2,#001h        ; 01be - P2:0=1                 [select row8(I)]
1145         mov     a,r4            ; 01c0 - a=r4(data)
1146         orl     bus,#008h       ; 01c1 - bus=d2h|08h=dah  D4=1  [Strobe?](1101 1010)
1147         anl     p2,#000h        ; 01c3 - P2:0=L                 [unselect row8(I)]
1148
1149 ; check sensor out(T0)
1150         jt0     X01d5           ; 01c5 - jump if T0==H
1151         jf0     X01cd           ; 01c7 - jump if F0==1
1152         jb0     X01d9           ; 01c9 - jump if a:bit0==1      [Settle]
1153         ; TO(sensor)==0 && F0==0 && a:bit0==0
1154         jmp     X01b2           ; 01cb -  }LOOP
1155
1156 ; record 1(a=a|01h) when key is on(T0=L) and F0==1
1157 ; T0(sensor)==L(off) && F0==1 (from 01c7)
1158 X01cd:  orl     a,#001h         ; 01cd - a=a|1                  [Set a:bit0=H]
1159         jmp     X01b2           ; 01cf - LOOP
1160
1161 ; record 0(a=a&feh) when key is off(T0=H) and F0==0
1162 ; T0(sensor)==H(on) && F0==0 && a:bit0==1(off) (from 01d7)
1163 X01d1:  anl     a,#0feh         ; 01d1 - a=a&feh                [Set a:bit0=L]
1164         jmp     X01b2           ; 01d3 - LOOP
1165
1166 ; scan LOOP again
1167 ; T0(sensor)==H(on) && F0==1 (from 01c5)
1168 X01d5:  jf0     X01b2           ; 01d5 - LOOP while F0==1
1169
1170 ; T0(sensor)==H(on) && F0==0
1171         jb0     X01d1           ; 01d7 - jump if a:bit0==1 [need to change r4(a) to 0]
1172
1173 ; next column
1174 ; T0(sensor)==H && F0==0 && a:bit0==0 OR
1175 ; T0(sensor)==L && F0==0 && a:bit0==1   (from 01c9)
1176 X01d9:  djnz    r7,X01b1        ; 01d9 - }LOOP_0 while --r7>0 [Next column]
1177         mov     r4,a            ; 01db - r4=a               a=r4=scanned data of Row8(I)
1178
1179
1180 ;;;;;;;;;;;;;;;;;;
1181 ;  Set parameters from scanned data of row 8(I)
1182 ;
1183 ;   INPUT:  a=r4=keyboard identity bits
1184 ;   OUTPUT: $21=keybaord identity bits, r4=$21&f0h
1185 ;
1186         anl     a,#0f0h         ; 01dc - a=a&f0h
1187         xrl     a,#020h         ; 01de - a=a^20h            (a==0010 xxxx)  6019273
1188         jz      X01ec           ; 01e0 - jump if a==0
1189         xrl     a,#010h         ; 01e2 - a=a^10h            (a==0011 xxxx) *6019284 when power on reset
1190         jz      X01f2           ; 01e4 - jump if a==0
1191         xrl     a,#070h         ; 01e6 - a=a^70h            (a==0100 xxxx)  6019303
1192         jz      X01f2           ; 01e8 - jump if a==0
1193         jmp     X01fa           ; 01ea -
1194
1195 ; $21==(0010 xxxx)  for 6019273(50-key)
1196 ; set break enalbe flag for Reset(or on other layout?)
1197 X01ec:  mov     r0,#022h        ; 01ec -
1198         mov     @r0,#001h       ; 01ee - $22=1      $22:bit0=break enable falg of ????
1199         jmp     X01fa           ; 01f0 -
1200
1201 ; $21==(0011 0010 | 0100 xxxx)  for 6019284(62-key) or 6019303(77-key) layout
1202 ; set break enable flag for LAlt and RAlt *6019284
1203 X01f2:  mov     r0,#02eh        ; 01f2 -
1204         mov     @r0,#001h       ; 01f4 - $2e=1      $2e:bit0=break enable flag of LAlt
1205         mov     r0,#024h        ; 01f6 -
1206         mov     @r0,#001h       ; 01f8 - $24=1      $24:bit0=break enable flag of RAlt
1207
1208 ; set $21 to scanned data of row 8(I)   [keyboard identity bits]
1209 X01fa:  mov     r0,#021h        ; 01fa -
1210         mov     a,r4            ; 01fc -
1211         mov     @r0,a           ; 01fd - ($21)=r4     $21: r4=identity bits(row 8(I))
1212         anl     a,#0f0h         ; 01fe -
1213         mov     r4,a            ; 0200 - r4=r4&f0h
1214         ret                     ; 0201 -
1215 ;
1216 ; End of Scan row8(I)
1217 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1218
1219
1220 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1221 ;
1222 ; Test and clear memory(3fh..00h) on Power on Reset
1223 ;
1224 X0202:  mov     r0,#03fh        ; 0202 -  $3f
1225 X0204:  mov     a,@r0           ; 0204 -  LOOP>>
1226         mov     r1,a            ; 0205 -  r1=(r0) r0=3f..00
1227         mov     a,#0ffh         ; 0206 -  a=ffh
1228         mov     @r0,a           ; 0208 -  (r0)=ffh
1229         xrl     a,@r0           ; 0209 -  a=a^ffh =0??
1230         jnz     X0224           ; 020a -  jump if a!=ffh    *always should be a=zero*
1231         mov     @r0,a           ; 020c -  (r0)=a    (=0)
1232         mov     a,@r0           ; 020d -  a=(r0)
1233         jnz     X0224           ; 020e -  jump if a!=ffh    *always should be a=zero*
1234         mov     a,r1            ; 0210 -  a=r1
1235         mov     @r0,a           ; 0211 -  (r0)=a (revert to origin value)
1236         djnz    r0,X0204        ; 0212 -  <<LOOP --r0
1237
1238 ;
1239 ; Test program memory(0,255..1 @page0,1,2,3)
1240 ;
1241 ; INPUT: r0=0 r4=??
1242 ; OUTPUT: r4=$21&07h|50h, a=swapHL(r4(original)) or feh
1243 X0214:  mov     a,r0            ; 0214 -  LOOP>>   a=r0=0
1244         call    X0029           ; 0215 -  r1=r1+(a), a=r0 (page0)
1245         call    X01a4           ; 0217 -  r1=r1+(a), a=r0 (page1)
1246         movp    a,@a            ; 0219 -
1247         call    X01a5           ; 021a -  r1=r1+(a), a=r0 (page2)
1248         movp3   a,@a            ; 021c -
1249         call    X01a5           ; 021d -  r1=r1+(a), a=r0 (page3)
1250         djnz    r0,X0214        ; 021f -  <<LOOP --r0
1251         mov     a,r1            ; 0221 -  a=r1  sum of program memory data
1252         jz      X0226           ; 0222 -  sum of program memory data != 0 if no error ???
1253
1254 ; Send FE on error and r4 on success
1255 X0224:  mov     r4,#0efh        ; 0224 -  r4=efh    Memory error
1256 X0226:  call    X0020           ; 0226 -  r4=$21&07h|50h, a=r4(keyboard id or efh)
1257         swap    a               ; 0228 -  swap a:h<->a:l
1258         orl     a,#0a0h         ; 0229 -  a=a|a0h(1010 iiii)    i:keyboard id(hi-bits)
1259         call    X0339           ; 022b -  queue data(a) to buffer
1260         call    X010b           ; 022d -  send kbd ID and wait for data from host   [FC command]
1261         strt    t               ; 022f -  start timer
1262 ; Usually first data form keyboard at startup is A3h(sum of program memory?).
1263 ; FEh for memory error??
1264 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1265
1266
1267
1268 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1269 ;
1270 ; Main??
1271 ;
1272 ; check scan code buffer to send
1273 X0230:  call    X002c           ; 0230 - receive/send data
1274         mov     a,r6            ; 0232 - a=r6 set by command FD Short Beep(0bh at 00edh)
1275         jz      X023d           ; 0233 -
1276         djnz    r6,X023d        ; 0235 - r6--
1277 ; Buzzer off
1278         anl     bus,#07fh       ; 0237 - BZ=L(off)   when get to r6==0  [Short Beep ends]
1279         mov     a,r4            ; 0239 -
1280         anl     a,#07fh         ; 023a -
1281         mov     r4,a            ; 023c - r4=r4&7fh(BZ=L:off) r4=bus-default
1282
1283 ; delay for scan    192*32cycle?
1284 X023d:  mov     a,t             ; 023d - a=t(timer)
1285         add     a,#064h         ; 023e - a=a+64h
1286         jnc     X023d           ; 0240 - delay for scan
1287         clr     a               ; 0242 - a=0
1288         mov     t,a             ; 0243 - t=0    timer clear
1289
1290 ; Start matrix scan
1291 ; r7=r4&c0h
1292 X0244:  mov     a,r4            ; 0244 - a=r4
1293         anl     a,#0c0h         ; 0245 - a=a&c0h        BZ=_,CLK=_,DAT=L:
1294         mov     r7,a            ; 0247 - r7=r4&c0h      r7=bus-current
1295         jf1     X0253           ; 0248 - jump if F1==1 (p1/p2)
1296
1297 ; F1==0
1298         cpl     f1              ; 024a - F1=1(=~F1)
1299         mov     r2,#03fh        ; 024b - r2=3fh         scan code seed
1300         mov     r3,#001h        ; 024d - r3=01h         row mask
1301         mov     r1,#015h        ; 024f - r1=15h         last key state
1302         jmp     X0263           ; 0251 - scan matrix p1 row
1303
1304 ; F1==1
1305 X0253:  clr     f0              ; 0253 - F0=0
1306         clr     f1              ; 0254 - F1=0
1307         mov     r2,#077h        ; 0255 - r2=77h         scan code seed
1308         mov     r3,#002h        ; 0257 - r3=02h
1309         mov     r1,#01ch        ; 0259 - r1=1ch         last key state
1310         jmp     X0287           ; 025b - Scan matrix p2 row
1311 ;
1312 ; INPUT:    F1=0
1313 X025d:  cpl     f1              ; 025d - F1=~F1=1
1314         call    X002c           ; 025e - receive/send data
1315         clr     f1              ; 0260 - F1=0
1316         jmp     X0244           ; 0261 -
1317
1318 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
1319 ;
1320 ; scan matrix p1 row
1321 ; INPUT: F1=1, r1=15h, r2=3fh, r3=01h, r7=r4&c0h
1322 ;       (r1): last state
1323 ;
1324 ; r0:col, r7:bus-current, r3:row(drive H), r4=bus-default
1325 ;
1326 ; $15: bit7
1327 ;
1328 ; bus:  xxxS Gccc
1329 ;
1330 X0263:  mov     a,#008h         ; 0263 - a=8 LOOP>>>
1331         mov     r0,a            ; 0265 - r0=08h =column
1332         orl     a,r7            ; 0266 - a=08h|r7
1333         mov     r7,a            ; 0267 - r7=a     =xxxx  1ccc(G:1 column:ccc) r7=P1 value
1334 X0268:  dec     r7              ; 0268 - LOOP>> r7--
1335         mov     a,r7            ; 0269 - a=r7
1336         outl    bus,a           ; 026a -                        [select column]
1337         orl     bus,#010h       ; 026b - sensor out=H           [sensor clamp=H]???
1338         mov     a,r3            ; 026d - a=r3                   current row
1339         outl    p1,a            ; 026e - drive line with H      [select row]
1340         mov     a,r4            ; 026f - a=r4                   bus default value
1341         outl    bus,a           ; 0270 -                        [revert bus default]
1342         orl     bus,#008h       ; 0271 - D3:H sensor-G          [strobe]??? hold? clean Sensor?
1343         anl     p1,#000h        ; 0273 -                        [unselect row]
1344
1345         jnt0    X02ab           ; 0275 - sensor out==0
1346 ; Sensor==1[key is on]
1347         mov     a,@r1           ; 0277 - a=$(r1); r1=15...  last key state
1348         jb7     X02e5           ; 0278 - jump if a:bit7==1(off) press
1349 ; a:bit7==0(last key state is on)  same as last
1350 ;On->On
1351
1352
1353 ; Go to next column
1354 X027a:  rl      a               ; 027a - a=a<<1
1355         mov     @r1,a           ; 027b - (r1)=a; (r1)=(r1)<<1   next col of last key state
1356 X027c:  dec     r2              ; 027c - r2--                   [key index of scan code table]
1357         djnz    r0,X0268        ; 027d - <<LOOP(8)              [next col]
1358
1359         dec     r1              ; 027f - r1--   15,14,13,12,11,10,0F,0E? [last key state]
1360         mov     a,r3            ; 0280 -
1361         rl      a               ; 0281 -
1362         mov     r3,a            ; 0282 - r3=r3<<1 next row
1363         jb0     X0230           ; 0283 - jump if a:bit0==1  scan end(goto Main loop)
1364         jmp     X0263           ; 0285 - <<<LOOP                [next row]
1365
1366
1367 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
1368 ;
1369 ; Scan matrix p2 row(F1==1)
1370 ; INPUT: F0=0, F1=0, r1=1ch, r2=77h, r3=02h, r7=bus-current, r4=bus-default
1371 ;
1372 ; r0:col, r7:bus-current, r3:row(drive H), r4=bus-default
1373 ;   key index: 77h-
1374 X0287:  mov     a,#008h         ; 0287 - a=8    LOOP>>
1375         mov     r0,a            ; 0289 - r0=8
1376         orl     a,r7            ; 028a - a=a|r7
1377         mov     r7,a            ; 028b - r7=a
1378 X028c:  dec     r7              ; 028c - r7-- LOOP>>
1379         mov     a,r7            ; 028d - a=r7
1380         outl    bus,a           ; 028e -                        [select column]
1381         mov     a,r4            ; 0293 -                        bus default value
1382         outl    bus,a           ; 0294 -                        [revert bus default]
1383         orl     bus,#008h       ; 0295 -                        [strobe]
1384         anl     p2,#000h        ; 0297 - p2=00h                 [unselect row]
1385         jnt0    X02ab           ; 0299 - jump if sensor out==0(key is on)
1386 ; sensor==1(key is off)
1387         mov     a,@r1           ; 029b - a=(r1)                 [last key state]
1388         jb7     X02e5           ; 029c - jump if a:bit7==1(off)  press
1389
1390 ; a:bit7==0(last key state is on)
1391 X029e:  rl      a               ; 029e - a=a<<1
1392         mov     @r1,a           ; 029f - (r1)=a                 [next last key bit]
1393 X02a0:  dec     r2              ; 02a0 - r2--(77h)
1394         djnz    r0,X028c        ; 02a1 - jump if r0--!=0 <<LOOP(8)
1395         dec     r1              ; 02a3 - r1--                   [next last key byte]
1396         mov     a,r3            ; 02a4 -
1397         rl      a               ; 02a5 -
1398         mov     r3,a            ; 02a6 - r3=r3<<1   [next row]??
1399         jb0     X025d           ; 02a7 -
1400         jmp     X0287           ; 02a9 - <<LOOP
1401
1402 ;
1403 ; debouncing and change last key state
1404 ;
1405 ; sensor out==0(press; key is on)
1406 ;
1407 ; debouncing
1408 X02ab:  call    X030d           ; 02ab - a=0(sensor out=1), ffh(sensor out=0)   [Sense key]
1409         jz      X02f8           ; 02ad - if a==0(key is off)
1410         call    X030d           ; 02af -                                        [Sense key]
1411         jz      X02f8           ; 02b1 - if a==0(key is off)
1412
1413 ; Sensor==0(a=ffh; press)
1414         mov     a,@r1           ; 02b3 - a=(r1) last key state????
1415         jb7     X02ca           ; 02b4 -
1416
1417 ;
1418 ; [release](off->on)
1419 ;
1420 ; last:bit7==0(off) && sensor=0(on)
1421         orl     a,#080h         ; 02b6 - 0:on   1:off
1422         rl      a               ; 02b8 -
1423         mov     @r1,a           ; 02b9 - (r1)=(r1)<<1   next column
1424         call    X0325           ; 02ba - key configure flag
1425                                 ;        (a:bit1=repeat enable, a:bit0=break enable)
1426 ; if keyconf:bit0==1 then set release flag
1427         jb0     X02fd           ; 02bc - r2=r2|80h          [press flag]
1428 ; if keyconf:bit1==1 then set repeat
1429         jb1     X02e1           ; 02be - r5=repeat delay    [repeat]
1430
1431 ; get scan code and queue it into buffer
1432 X02c0:  call    translate034E   ; 02c0 - a=scancode
1433         call    X0339           ; 02c2 - queue data to buffer
1434         call    X0303           ; 02c4 -                    [r1=a=address of last key state]
1435 X02c6:  jf1     X027c           ; 02c6 - next col(F1==1)
1436         jmp     X02a0           ; 02c8 - next col(F1==0)
1437
1438 ;
1439 ; [hold key]
1440 ;
1441 ; last key is on and sensor==0(on)     (on->on)
1442 X02ca:  rl      a               ; 02ca -
1443         mov     @r1,a           ; 02cb - (r1)=(r1)<<1
1444         call    X0325           ; 02cc - key configure flag
1445                                 ;        (a:bit1=repeat enable, a:bit0=break enable)
1446 ; repeat:flag
1447         jb1     X02d4           ; 02ce -                    [repeat]
1448
1449 ; if repeat:flag(bit1)==0  (no repeat)
1450 X02d0:  call    X0303           ; 02d0 - r1=r2&0fh+0eh      address of last key state
1451         jmp     X02c6           ; 02d2 - goto next col
1452
1453 ; if flag:bit1==1  (repeat)
1454 X02d4:  jf0     X02dd           ; 02d4 -
1455
1456 ; F0==0
1457         cpl     f0              ; 02d6 - F0=~F0=1
1458         djnz    r5,X02d0        ; 02d7 -
1459         mov     r5,#007h        ; 02d9 - r5=07h             repeat interval
1460         jmp     X02c0           ; 02db - send scan code
1461
1462 ; F0==1
1463 X02dd:  mov     r5,#028h        ; 02dd - r5=28h             repeat delay(for first repeat)
1464         jmp     X02d0           ; 02df -
1465 ;
1466 X02e1:  mov     r5,#028h        ; 02e1 - r5=28h             repeat delay(for first repeat)
1467         jmp     X02c0           ; 02e3 - send scan code
1468
1469
1470 ;
1471 ; debouncing and change last key state: press
1472 ;
1473 ;   INPUT: (r1): last key status
1474 ;
1475 ; (r1):bit7==1(last key is on) &&  Sensor==1(key is off)  [release]
1476 X02e5:  call    X030d           ; 02e5 - a=0(sensor out=1), ffh(sensor out=0)   [Sense key]
1477         jnz     X02f8           ; 02e7 -
1478         call    X030d           ; 02e9 -                                        [Sense key]
1479         jnz     X02f8           ; 02eb - \_debouncing
1480 ; Sensor==1(a=0)                                                                [Debounced]
1481
1482 ;
1483 ; on->off [release]
1484 ;
1485         mov     a,@r1           ; 02ed - a=(r1) RAM
1486         anl     a,#07fh         ; 02ee - a=a&7fh        last state=0(0:on 1:off)
1487         rl      a               ; 02f0 - a=a<<1
1488         mov     @r1,a           ; 02f1 - (r1)=a
1489 ;
1490         call    X0325           ; 02f2 - key configure flag
1491                                 ;        (a:bit1=repeat enable, a:bit0=break enable)
1492         jb0     X02c0           ; 02f4 - goto translate if a:bit0==1
1493         jmp     X02d0           ; 02f6 -
1494
1495 ; go to next col scan   Sensor==1
1496 X02f8:  mov     a,@r1           ; 02f8 -
1497         jf1     X027a           ; 02f9 - goto next col scan(p1) if F1==1        [Next column]
1498         jmp     X029e           ; 02fb - goto next col scan(p2) else            [Next column]
1499
1500 ;
1501 ; add press flag(bit8)
1502 ; r2=key index
1503 X02fd:  mov     a,r2            ; 02fd -                                        [key index]
1504         orl     a,#080h         ; 02fe -
1505         mov     r2,a            ; 0300 - r2=r2|80h  **press flag**
1506         jmp     X02c0           ; 0301 -
1507
1508 ; Address of last key state
1509 ; INPUT: r2=key index
1510 ; OUTPUT: r1=(r2>>3)&0fh+0eh    = address of last key state
1511 X0303:  mov     a,r2            ; 0303 - a=r2   key index
1512         rr      a               ; 0304 -
1513         rr      a               ; 0305 -
1514         rr      a               ; 0306 - a= a>>3
1515         anl     a,#00fh         ; 0307 - a= a & 0fh
1516         add     a,#00eh         ; 0309 - a= a + 0eh
1517         mov     r1,a            ; 030b - r1=a
1518         ret                     ; 030c -
1519
1520 ;;;;;;;;;;;;;;;;;;;;;;;
1521 ; Sense key
1522 ;   INPUT: r7: bus-current, F1:0(p2),1(p1) r4=bus-default, r3=row
1523 ;   RETURN: a=0xff(sensor out=0, press), 0(sensor out=1, release)
1524 ;
1525 X030d:  mov     a,r7            ; 030d - r7: bus-current
1526         outl    bus,a           ; 030e -                            [Select column]
1527         orl     bus,#010h       ; 030f -                            [Charge: D4]
1528         mov     a,r3            ; 0311 - r3: row(drive) select      p1(F1=1)/p2(F1=0) setting
1529         jf1     X0317           ; 0312 -
1530 ; F1==0
1531         outl    p2,a            ; 0314 - set p2                     [Select row]
1532         jmp     X0318           ; 0315 -
1533 ; F1==1
1534 X0317:  outl    p1,a            ; 0317 - set p1                     [Select row]
1535
1536 X0318:  mov     a,r4            ; 0318 - r4: bus-default
1537         outl    bus,a           ; 0319 - set bus
1538         clr     a               ; 031a - a=0
1539         orl     bus,#008h       ; 031b -                            [Strobe: D3]
1540         anl     p1,#000h        ; 031d - clear p1                   [Unselect row]
1541         anl     p2,#000h        ; 031f - clear p2                   [Unselect row]
1542
1543         jt0     X0324           ; 0321 - sensor out==1
1544 sensor out==0
1545         cpl     a               ; 0323 -  a=0xff                    [press(on)]
1546 sensor out==1
1547 X0324:  ret                     ; 0324 -  a=0                       [release(off)]
1548 ;
1549 ; End of Main
1550 ;
1551 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1552
1553
1554
1555 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1556 ;
1557 ; key configure flags
1558 ;
1559 ; INPUT: r2=key index(p1:-3fh, p2:-77h)    (aaaaaaii)
1560 : OUTPUT: a=Key configure 2-bit flags;  bit0 and 1 are only valid. (------rb)
1561 ;
1562 :   Key configure flags are retained in RAM($22-3F) and
1563 ;   Key configure flags use 2bit per key so that a byte can has flags of four key like:
1564 ;       bit 7   6   5   4   3   2   1   0
1565 ;           3r  3b  2r  2b  1r  1b  0r  0b
1566 ;   where r=repeat enable, b=break code(release) eanble
1567 ;
1568 X0325:  mov     a,r2            ; 0325 - a=r2           index
1569         rr      a               ; 0326 -
1570         rr      a               ; 0327 - a=a>>2         bit7-2 of index(aaaaaa)
1571         add     a,#022h         ; 0328 - a=a+22h        $22+aaaaaa
1572         mov     r1,a            ; 032a - r1=a
1573         mov     a,@r1           ; 032b - a=(r1)         $22-3F(ignored bit7,bit6)
1574         mov     r1,a            ; 032c - r1=a           r1=($22-3F) ????
1575         mov     a,r2            ; 032d - a=r2           index
1576         anl     a,#003h         ; 032e - a=a&03h        a=bit0,bit1 of index
1577         xch     a,r1            ; 0330 - a<->r1         r1=bit0,bit1 of index, a=($22-3F)
1578         inc     r1              ; 0331 - r1++           =1-4
1579 X0332:  djnz    r1,X0335        ; 0332 - while --r1>0
1580         ret                     ; 0334 -
1581
1582 ; place flags of the key on bit0 and 1
1583 X0335:  rr      a               ; 0335 -
1584         rr      a               ; 0336 - a=a>>2; a=$22-3F
1585         jmp     X0332           ; 0337 -
1586
1587 ;
1588 ; Queue data to bottom of outgoing buffer(bank1:r5,r6,r7)
1589 ; INPUT: a=data, r2=???
1590 ; OUTPUT: r2=r2&07h
1591 ; a->r5->r6->r7
1592 X0339:  sel     rb1             ; 0339 -   switch to bank1
1593         inc     a               ; 033a -   a++
1594         xch     a,r5            ; 033b -   a<->r5
1595         jz      X0348           ; 033c -
1596         xch     a,r5            ; 033e -
1597         xch     a,r6            ; 033f -
1598         jz      X0348           ; 0340 -
1599         xch     a,r6            ; 0342 -
1600         xch     a,r7            ; 0343 -
1601         jz      X0348           ; 0344 -
1602         mov     r7,#0ffh        ; 0346 -   buffer overflow
1603 X0348:  sel     rb0             ; 0348 -   switch to bank0
1604         mov     a,r2            ; 0349 -   a=r2
1605         anl     a,#07fh         ; 034a -   a=a&7fh
1606         mov     r2,a            ; 034c -   r2=a
1607         ret                     ; 034d -
1608 ;
1609 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1610
1611
1612
1613 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1614 ;
1615 ; Translate key index into scancode
1616 ;
1617 ; INPUT: r2=keyindex [bit7:release flag(1:release/0:press), bit6-0:index]
1618 ; OUTPUT: a=scancode
1619 translate034E:
1620         mov     r1,#021h        ; 034e -
1621         mov     a,@r1           ; 0350 - a=$21  $21:bit6,5,4 = traslate table
1622         anl     a,#0f0h         ; 0351 - a=a & f0h
1623         xrl     a,#020h         ; 0353 - a=a ^ 20h      $21:bit5(0010 0000) 0010 xxxx => table1
1624         jz      X0361           ; 0355 - if a==0        read table1     (6019273 50-key)
1625         xrl     a,#010h         ; 0357 - a=a ^ 10h      $21:bit4(0001 0000) 0011 xxxx => table2
1626         jz      X0370           ; 0359 -                read table2     (6019284 62-key)
1627         xrl     a,#070h         ; 035b - a=a & 70h      $21:bit6(0111 0000) 0100 xxxx => table2
1628         jz      X0370           ; 035d -                read table2     (6019303 77-key)
1629         mov     a,r2            ; 035f -                else use r2(keyindex) instead of scancode
1630         ret                     ; 0360 -
1631 ; table1(8x7=56)
1632 X0361:  mov     a,r2            ; 0361 - keyindex
1633         anl     a,#07fh         ; 0362 -
1634         add     a,#078h         ; 0364 - table1
1635 ; read table
1636 X0366:  movp3   a,@a            ; 0366 - read scancode from table a=scan code
1637         xch     a,r2            ; 0367 - a=keyindex, r2=scancode
1638         jb7     X036c           ; 0368 - if keyindex:bit7==1 [relase event]
1639         xch     a,r2            ; 036a - a=scancode, r2=keyindex
1640         ret                     ; 036b -
1641 ; release flag
1642 X036c:  xch     a,r2            ; 036c -
1643         orl     a,#080h         ; 036d - [[[[[release flag(bit7)]]]]]
1644         ret                     ; 036f - a: scan code
1645 ; table2(8X10=80)
1646 X0370:  mov     a,r2            ; 0370 -
1647         anl     a,#07fh         ; 0371 -
1648         add     a,#0b0h         ; 0373 - table2
1649         jmp     X0366           ; 0375 - read table
1650
1651
1652 ; maybe 'salt' to make sum of program memory 'zero'(at 0222h)
1653         db      0b6h                                    ; 0377 6
1654
1655
1656 ;;;;;;;;;;;;;;;;;;
1657 ;
1658 ; Scancode table
1659 ;
1660
1661 ;;;;;;;;;;;;;;;;;;
1662 ; Used for 6019273                                        Add  Key              Parameter RAM
1663 table1: db      03fh,037h,03ah,036h,02ah,035h,022h,023h ; 0378
1664         db      03bh,02bh,039h,031h,032h,029h,021h,0ffh ; 0380
1665         db      033h,038h,0ffh,030h,028h,0ffh,020h,0ffh ; 0388
1666         db      017h,01dh,01ch,015h,00ch,00dh,004h,005h ; 0390
1667         db      00fh,01fh,01bh,013h,014h,00bh,003h,0ffh ; 0398
1668         db      00eh,01ah,019h,012h,009h,00ah,001h,002h ; 03a0
1669         db      016h,01eh,018h,010h,011h,008h,000h,0ffh ; 03a8
1670
1671 ;;;;;;;;;;;;;;;;;;
1672 ; Used for 6019284 and 6019303                            Add  Key              Parameter RAM
1673 table2: db      02fh,03dh,03ch,02dh,01dh,01ch,00ch,00eh ; 03b0 Enter ... BS     $22, $23
1674         db      03fh,042h,03bh,02bh,02ch,01bh,01fh,00dh ; 03b8 RAlt ...         $24, $25
1675         db      039h,03ah,029h,02ah,002h,003h,00ah,00fh ; 03c0 ...              $26, $27
1676         db      038h,037h,028h,027h,017h,001h,008h,009h ; 03c8 ...              $28, $29
1677         db      040h,036h,025h,026h,015h,016h,011h,012h ; 03d0 ...              $2a, $2b
1678         db      035h,034h,023h,024h,013h,014h,01ah,010h ; 03d8 ...              $2c, $2d
1679         db      03fh,032h,033h,022h,021h,006h,005h,019h ; 03e0 LAlt ...         $2e, $2f
1680         db      031h,041h,03eh,030h,020h,004h,000h,018h ; 03e8 Reset ... 1      $30, $31
1681         db      071h,076h,075h,066h,055h,056h,045h,046h ; 03f0 Used for 77-key  $32, $33
1682         db      077h,067h,074h,064h,065h,054h,0ffh,044h ; 03f8 Used for 77-key  $34, $35
1683 ;
1684 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1685
1686
1687
1688 ;
1689 ;       symbol equates
1690 ;
1691 ;  these are symbols from the control
1692 ;  file that are referenced in the code
1693 ;
1694 jump_table      equ     0fah
1695 ;
1696         end