first commit

internal/hhkb/proto.go

@@ -0,0 +1,168 @@
+package hhkb
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+)
+
+// Command ids — byte 3 of every request.
+const (
+	cmdNotifyApp     = 1
+	cmdGetInfo       = 2
+	cmdFactoryReset  = 3
+	cmdConfirmKeymap = 4
+	cmdGetMode       = 6
+	cmdResetDIP      = 7
+	cmdWriteKeymap   = 134
+	cmdGetKeymap     = 135
+)
+
+// Info describes the connected keyboard.
+type Info struct {
+	TypeNumber   string
+	Revision     string
+	Serial       string
+	AppFirmware  string
+	BootFirmware string
+}
+
+// Info reads the keyboard's identification.
+func (d *Device) Info() (Info, error) {
+	r, err := d.do(cmdGetInfo)
+	if err != nil {
+		return Info{}, err
+	}
+	p := r[6:]
+	return Info{
+		TypeNumber:   cstr(p[0:20]),
+		Revision:     cstr(p[20:24]),
+		Serial:       cstr(p[24:40]),
+		AppFirmware:  fmt.Sprintf("%X", p[40:48]),
+		BootFirmware: fmt.Sprintf("%X", p[48:56]),
+	}, nil
+}
+
+// Mode reads the active keyboard mode (set by DIP switches).
+func (d *Device) Mode() (Mode, error) {
+	r, err := d.do(cmdGetMode)
+	if err != nil {
+		return 0, err
+	}
+	return Mode(r[6]), nil
+}
+
+// ReadLayer reads one full key layer: the base layer, or the Fn layer when
+// fn is true. The reply arrives as three reports that tile the 128-byte layer.
+func (d *Device) ReadLayer(fn bool) (Layer, error) {
+	mode, err := d.Mode()
+	if err != nil {
+		return Layer{}, err
+	}
+	return d.readLayer(mode, fn)
+}
+
+func (d *Device) readLayer(mode Mode, fn bool) (Layer, error) {
+	var lay Layer
+	if err := d.send(request(cmdGetKeymap, 0, 2, byte(mode), boolByte(fn))); err != nil {
+		return lay, err
+	}
+	for _, seg := range [...]struct{ off, n int }{{0, 58}, {58, 58}, {116, 12}} {
+		r, err := d.recv()
+		if err != nil {
+			return lay, err
+		}
+		copy(lay[seg.off:seg.off+seg.n], r[6:6+seg.n])
+	}
+	return lay, nil
+}
+
+// writeLayer uploads a full layer in the three passes the firmware expects.
+// The leading byte pairs (65,59 / 130,59 / 195,12) are offset and length
+// markers the controller verifies; the data window is mode+fn followed by the
+// 128 key bytes.
+func (d *Device) writeLayer(mode Mode, fn bool, lay Layer) error {
+	passes := []struct {
+		mark [2]byte
+		head []byte
+		data []byte
+	}{
+		{[2]byte{65, 59}, []byte{byte(mode), boolByte(fn)}, lay[0:57]},
+		{[2]byte{130, 59}, nil, lay[57:116]},
+		{[2]byte{195, 12}, nil, lay[116:128]},
+	}
+	for _, p := range passes {
+		args := append([]byte{p.mark[0], p.mark[1]}, p.head...)
+		args = append(args, p.data...)
+		if _, err := d.do(cmdWriteKeymap, args...); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Remap assigns scancode to a key (by its key number) on the base or Fn layer.
+// It mirrors the official tool's sequence: announce the tool, edit the layer,
+// write it back, commit, and reset DIP state. The change is reversible with
+// Reset or by remapping again.
+func (d *Device) Remap(keyNum int, scancode byte, fn bool) error {
+	if keyNum < 1 || keyNum >= LayerLen {
+		return fmt.Errorf("key number %d out of range", keyNum)
+	}
+	if err := d.notifyApp(true); err != nil {
+		return err
+	}
+	defer d.notifyApp(false)
+
+	mode, err := d.Mode()
+	if err != nil {
+		return err
+	}
+	lay, err := d.readLayer(mode, fn)
+	if err != nil {
+		return err
+	}
+	lay[keyNum] = scancode
+
+	if err := d.writeLayer(mode, fn, lay); err != nil {
+		return err
+	}
+	if _, err := d.do(cmdConfirmKeymap); err != nil {
+		return err
+	}
+	_, err = d.do(cmdResetDIP, 0, 1)
+	return err
+}
+
+// Reset restores the factory default keymap.
+func (d *Device) Reset() error {
+	r, err := d.do(cmdFactoryReset)
+	if err != nil {
+		return err
+	}
+	if !bytes.HasPrefix(r, []byte{0x55, 0x55, 0x03, 0x00}) {
+		return fmt.Errorf("unexpected factory-reset reply: % X", r[:6])
+	}
+	return nil
+}
+
+// notifyApp tells the keyboard whether the configuration tool is active.
+func (d *Device) notifyApp(open bool) error {
+	_, err := d.do(cmdNotifyApp, 0, 1, boolByte(!open))
+	return err
+}
+
+func boolByte(b bool) byte {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+// cstr converts a fixed-width, NUL-padded field into a Go string.
+func cstr(b []byte) string {
+	if i := strings.IndexByte(string(b), 0); i >= 0 {
+		b = b[:i]
+	}
+	return strings.TrimSpace(string(b))
+}