src - OpenBSD base system

diff options


context:
space:
mode:

author	Miod Vallat <miod@cvs.openbsd.org>	2006-01-04 20:39:07 +0000
committer	Miod Vallat <miod@cvs.openbsd.org>	2006-01-04 20:39:07 +0000
commit	b5304bb58ccc8685d27ff0f96701bb1cb258a6b9 (patch)
tree	4a5df4ff90f4b17e9461da71efb1bb18e882b5a2 /sys/arch/mac68k/dev
parent	15d15e3ad69f61e77c02fed009906131becd759f (diff)

Import NetBSD's direct adb code on mac68k, switching to real keyboard and mouse

drivers, and to wscons as the console; a few parts borrowed from OpenBSD/macppc as well. Currently only working with displays configured in 1bpp or 8bpp modes; this limitation will be worked on ASAP. Tested by claudio@ kettenis@ martin@ nick@ and I on various models. X11 changes coming soon.

Diffstat (limited to 'sys/arch/mac68k/dev')

-rw-r--r--

sys/arch/mac68k/dev/6x10.h

1416

-rw-r--r--

sys/arch/mac68k/dev/adb.c

660

-rw-r--r--

sys/arch/mac68k/dev/adb_direct.c

2220

-rw-r--r--

sys/arch/mac68k/dev/adbsys.c

315

-rw-r--r--

sys/arch/mac68k/dev/adbsysasm.s

-rw-r--r--

sys/arch/mac68k/dev/adbvar.h

-rw-r--r--

sys/arch/mac68k/dev/akbd.c

536

-rw-r--r--

sys/arch/mac68k/dev/akbdmap.h

431

-rw-r--r--

sys/arch/mac68k/dev/akbdvar.h

-rw-r--r--

sys/arch/mac68k/dev/ams.c

535

-rw-r--r--

sys/arch/mac68k/dev/amsvar.h

-rw-r--r--

sys/arch/mac68k/dev/grf.c

315

-rw-r--r--

sys/arch/mac68k/dev/grf_iv.c

-rw-r--r--

sys/arch/mac68k/dev/grf_mv.c

-rw-r--r--

sys/arch/mac68k/dev/grf_subr.c

-rw-r--r--

sys/arch/mac68k/dev/grfvar.h

-rw-r--r--

sys/arch/mac68k/dev/ite.c

1345

-rw-r--r--

sys/arch/mac68k/dev/macfb.c

359

-rw-r--r--

sys/arch/mac68k/dev/macfbvar.h (renamed from sys/arch/mac68k/dev/itevar.h)

-rw-r--r--

sys/arch/mac68k/dev/pm_direct.c

806

-rw-r--r--

sys/arch/mac68k/dev/pm_direct.h

21 files changed, 4110 insertions, 5327 deletions

diff --git a/sys/arch/mac68k/dev/6x10.h b/sys/arch/mac68k/dev/6x10.h
deleted file mode 100644
index c3c20b49c75..00000000000
--- a/sys/arch/mac68k/dev/6x10.h
+++ /dev/null

@@ -1,1416 +0,0 @@

-/* $OpenBSD: 6x10.h,v 1.2 1996/05/26 18:35:13 briggs Exp $ */

-/* $NetBSD: 6x10.h,v 1.4 1995/04/21 02:47:35 briggs Exp $ */

-/* This file was automatically generated by the program "sf" from */

-/* the Bitmap Description Format file "6x10.bdf". */

-static unsigned char Font6x10[] = {

- 0x00, /* ........ *//* (char = 0, 0x00) */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 1, 0x01) */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x1F, /* .#####.. */

- 0x0E, /* ..###... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 2, 0x02) */

- 0x15, /* .#.#.#.. */

- 0x0A, /* ..#.#... */

- 0x15, /* .#.#.#.. */

- 0x0A, /* ..#.#... */

- 0x15, /* .#.#.#.. */

- 0x0A, /* ..#.#... */

- 0x15, /* .#.#.#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 3, 0x03) */

- 0x12, /* .#..#... */

- 0x1E, /* .####... */

- 0x12, /* .#..#... */

- 0x0F, /* ..####.. */

- 0x02, /* ....#... */

- 0x00, /* ........ *//* (char = 4, 0x04) */

- 0x1C, /* .###.... */

- 0x10, /* .#...... */

- 0x18, /* .##..... */

- 0x10, /* .#...... */

- 0x17, /* .#.###.. */

- 0x04, /* ...#.... */

- 0x06, /* ...##... */

- 0x04, /* ...#.... */

- 0x00, /* ........ *//* (char = 5, 0x05) */

- 0x0E, /* ..###... */

- 0x10, /* .#...... */

- 0x0E, /* ..###... */

- 0x09, /* ..#..#.. */

- 0x0E, /* ..###... */

- 0x09, /* ..#..#.. */

- 0x00, /* ........ *//* (char = 6, 0x06) */

- 0x10, /* .#...... */

- 0x1E, /* .####... */

- 0x0F, /* ..####.. */

- 0x08, /* ..#..... */

- 0x0E, /* ..###... */

- 0x08, /* ..#..... */

- 0x00, /* ........ *//* (char = 7, 0x07) */

- 0x04, /* ...#.... */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 8, 0x08) */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x1F, /* .#####.. */

- 0x04, /* ...#.... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 9, 0x09) */

- 0x12, /* .#..#... */

- 0x1A, /* .##.#... */

- 0x16, /* .#.##... */

- 0x12, /* .#..#... */

- 0x08, /* ..#..... */

- 0x0F, /* ..####.. */

- 0x00, /* ........ *//* (char = 10, 0x0a) */

- 0x12, /* .#..#... */

- 0x0C, /* ..##.... */

- 0x08, /* ..#..... */

- 0x0F, /* ..####.. */

- 0x02, /* ....#... */

- 0x04, /* ...#.... *//* (char = 11, 0x0b) */

- 0x04, /* ...#.... */

- 0x3C, /* ####.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 12, 0x0c) */

- 0x00, /* ........ */

- 0x3C, /* ####.... */

- 0x04, /* ...#.... */

- 0x00, /* ........ *//* (char = 13, 0x0d) */

- 0x00, /* ........ */

- 0x07, /* ...###.. */

- 0x04, /* ...#.... */

- 0x04, /* ...#.... *//* (char = 14, 0x0e) */

- 0x04, /* ...#.... */

- 0x07, /* ...###.. */

- 0x00, /* ........ */

- 0x04, /* ...#.... *//* (char = 15, 0x0f) */

- 0x04, /* ...#.... */

- 0x3F, /* ######.. */

- 0x04, /* ...#.... */

- 0x3F, /* ######.. *//* (char = 16, 0x10) */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 17, 0x11) */

- 0x00, /* ........ */

- 0x3F, /* ######.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 18, 0x12) */

- 0x00, /* ........ */

- 0x3F, /* ######.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 19, 0x13) */

- 0x00, /* ........ */

- 0x3F, /* ######.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 20, 0x14) */

- 0x00, /* ........ */

- 0x3F, /* ######.. */

- 0x00, /* ........ */

- 0x04, /* ...#.... *//* (char = 21, 0x15) */

- 0x04, /* ...#.... */

- 0x07, /* ...###.. */

- 0x04, /* ...#.... */

- 0x04, /* ...#.... *//* (char = 22, 0x16) */

- 0x04, /* ...#.... */

- 0x3C, /* ####.... */

- 0x04, /* ...#.... */

- 0x04, /* ...#.... *//* (char = 23, 0x17) */

- 0x04, /* ...#.... */

- 0x3F, /* ######.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 24, 0x18) */

- 0x00, /* ........ */

- 0x3F, /* ######.. */

- 0x04, /* ...#.... */

- 0x04, /* ...#.... *//* (char = 25, 0x19) */

- 0x04, /* ...#.... */

- 0x00, /* ........ *//* (char = 26, 0x1a) */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x08, /* ..#..... */

- 0x02, /* ....#... */

- 0x01, /* .....#.. */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 27, 0x1b) */

- 0x10, /* .#...... */

- 0x08, /* ..#..... */

- 0x02, /* ....#... */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 28, 0x1c) */

- 0x00, /* ........ */

- 0x1F, /* .#####.. */

- 0x0A, /* ..#.#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 29, 0x1d) */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x1F, /* .#####.. */

- 0x04, /* ...#.... */

- 0x1F, /* .#####.. */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 30, 0x1e) */

- 0x06, /* ...##... */

- 0x09, /* ..#..#.. */

- 0x08, /* ..#..... */

- 0x1C, /* .###.... */

- 0x08, /* ..#..... */

- 0x09, /* ..#..#.. */

- 0x16, /* .#.##... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 31, 0x1f) */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 32, 0x20) */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 33, 0x21) */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 34, 0x22) */

- 0x0A, /* ..#.#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 35, 0x23) */

- 0x0A, /* ..#.#... */

- 0x1F, /* .#####.. */

- 0x0A, /* ..#.#... */

- 0x1F, /* .#####.. */

- 0x0A, /* ..#.#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 36, 0x24) */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x14, /* .#.#.... */

- 0x0E, /* ..###... */

- 0x05, /* ...#.#.. */

- 0x0E, /* ..###... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 37, 0x25) */

- 0x09, /* ..#..#.. */

- 0x15, /* .#.#.#.. */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x0A, /* ..#.#... */

- 0x15, /* .#.#.#.. */

- 0x12, /* .#..#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 38, 0x26) */

- 0x08, /* ..#..... */

- 0x14, /* .#.#.... */

- 0x08, /* ..#..... */

- 0x15, /* .#.#.#.. */

- 0x12, /* .#..#... */

- 0x0D, /* ..##.#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 39, 0x27) */

- 0x06, /* ...##... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 40, 0x28) */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x04, /* ...#.... */

- 0x02, /* ....#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 41, 0x29) */

- 0x08, /* ..#..... */

- 0x04, /* ...#.... */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 42, 0x2a) */

- 0x00, /* ........ */

- 0x11, /* .#...#.. */

- 0x0A, /* ..#.#... */

- 0x1F, /* .#####.. */

- 0x0A, /* ..#.#... */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 43, 0x2b) */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x1F, /* .#####.. */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 44, 0x2c) */

- 0x00, /* ........ */

- 0x06, /* ...##... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 45, 0x2d) */

- 0x00, /* ........ */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 46, 0x2e) */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 47, 0x2f) */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 48, 0x30) */

- 0x04, /* ...#.... */

- 0x0A, /* ..#.#... */

- 0x11, /* .#...#.. */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 49, 0x31) */

- 0x04, /* ...#.... */

- 0x0C, /* ..##.... */

- 0x14, /* .#.#.... */

- 0x04, /* ...#.... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 50, 0x32) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x01, /* .....#.. */

- 0x06, /* ...##... */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 51, 0x33) */

- 0x1F, /* .#####.. */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x06, /* ...##... */

- 0x01, /* .....#.. */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 52, 0x34) */

- 0x02, /* ....#... */

- 0x06, /* ...##... */

- 0x0A, /* ..#.#... */

- 0x12, /* .#..#... */

- 0x1F, /* .#####.. */

- 0x02, /* ....#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 53, 0x35) */

- 0x1F, /* .#####.. */

- 0x10, /* .#...... */

- 0x16, /* .#.##... */

- 0x19, /* .##..#.. */

- 0x01, /* .....#.. */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 54, 0x36) */

- 0x06, /* ...##... */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x16, /* .#.##... */

- 0x19, /* .##..#.. */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 55, 0x37) */

- 0x1F, /* .#####.. */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 56, 0x38) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 57, 0x39) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x13, /* .#..##.. */

- 0x0D, /* ..##.#.. */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x0C, /* ..##.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 58, 0x3a) */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 59, 0x3b) */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x06, /* ...##... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 60, 0x3c) */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x04, /* ...#.... */

- 0x02, /* ....#... */

- 0x01, /* .....#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 61, 0x3d) */

- 0x00, /* ........ */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 62, 0x3e) */

- 0x10, /* .#...... */

- 0x08, /* ..#..... */

- 0x04, /* ...#.... */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 63, 0x3f) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 64, 0x40) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x13, /* .#..##.. */

- 0x15, /* .#.#.#.. */

- 0x16, /* .#.##... */

- 0x10, /* .#...... */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 65, 0x41) */

- 0x04, /* ...#.... */

- 0x0A, /* ..#.#... */

- 0x11, /* .#...#.. */

- 0x1F, /* .#####.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 66, 0x42) */

- 0x1E, /* .####... */

- 0x09, /* ..#..#.. */

- 0x0E, /* ..###... */

- 0x09, /* ..#..#.. */

- 0x1E, /* .####... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 67, 0x43) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x10, /* .#...... */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 68, 0x44) */

- 0x1E, /* .####... */

- 0x09, /* ..#..#.. */

- 0x1E, /* .####... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 69, 0x45) */

- 0x1F, /* .#####.. */

- 0x10, /* .#...... */

- 0x1E, /* .####... */

- 0x10, /* .#...... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 70, 0x46) */

- 0x1F, /* .#####.. */

- 0x10, /* .#...... */

- 0x1E, /* .####... */

- 0x10, /* .#...... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 71, 0x47) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x10, /* .#...... */

- 0x13, /* .#..##.. */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 72, 0x48) */

- 0x11, /* .#...#.. */

- 0x1F, /* .#####.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 73, 0x49) */

- 0x0E, /* ..###... */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 74, 0x4a) */

- 0x07, /* ...###.. */

- 0x01, /* .....#.. */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 75, 0x4b) */

- 0x11, /* .#...#.. */

- 0x12, /* .#..#... */

- 0x14, /* .#.#.... */

- 0x18, /* .##..... */

- 0x14, /* .#.#.... */

- 0x12, /* .#..#... */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 76, 0x4c) */

- 0x10, /* .#...... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 77, 0x4d) */

- 0x11, /* .#...#.. */

- 0x1B, /* .##.##.. */

- 0x15, /* .#.#.#.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 78, 0x4e) */

- 0x11, /* .#...#.. */

- 0x19, /* .##..#.. */

- 0x15, /* .#.#.#.. */

- 0x13, /* .#..##.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 79, 0x4f) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 80, 0x50) */

- 0x1E, /* .####... */

- 0x11, /* .#...#.. */

- 0x1E, /* .####... */

- 0x10, /* .#...... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 81, 0x51) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x15, /* .#.#.#.. */

- 0x0E, /* ..###... */

- 0x01, /* .....#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 82, 0x52) */

- 0x1E, /* .####... */

- 0x11, /* .#...#.. */

- 0x1E, /* .####... */

- 0x14, /* .#.#.... */

- 0x12, /* .#..#... */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 83, 0x53) */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x10, /* .#...... */

- 0x0E, /* ..###... */

- 0x01, /* .....#.. */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 84, 0x54) */

- 0x1F, /* .#####.. */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 85, 0x55) */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 86, 0x56) */

- 0x11, /* .#...#.. */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 87, 0x57) */

- 0x11, /* .#...#.. */

- 0x15, /* .#.#.#.. */

- 0x1B, /* .##.##.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 88, 0x58) */

- 0x11, /* .#...#.. */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x0A, /* ..#.#... */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 89, 0x59) */

- 0x11, /* .#...#.. */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 90, 0x5a) */

- 0x1F, /* .#####.. */

- 0x01, /* .....#.. */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x10, /* .#...... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 91, 0x5b) */

- 0x0E, /* ..###... */

- 0x08, /* ..#..... */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 92, 0x5c) */

- 0x10, /* .#...... */

- 0x08, /* ..#..... */

- 0x04, /* ...#.... */

- 0x02, /* ....#... */

- 0x01, /* .....#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 93, 0x5d) */

- 0x0E, /* ..###... */

- 0x02, /* ....#... */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 94, 0x5e) */

- 0x04, /* ...#.... */

- 0x0A, /* ..#.#... */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 95, 0x5f) */

- 0x00, /* ........ */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 96, 0x60) */

- 0x0C, /* ..##.... */

- 0x04, /* ...#.... */

- 0x02, /* ....#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 97, 0x61) */

- 0x00, /* ........ */

- 0x0E, /* ..###... */

- 0x01, /* .....#.. */

- 0x0F, /* ..####.. */

- 0x11, /* .#...#.. */

- 0x0F, /* ..####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 98, 0x62) */

- 0x10, /* .#...... */

- 0x16, /* .#.##... */

- 0x19, /* .##..#.. */

- 0x11, /* .#...#.. */

- 0x19, /* .##..#.. */

- 0x16, /* .#.##... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 99, 0x63) */

- 0x00, /* ........ */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x10, /* .#...... */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 100, 0x64) */

- 0x01, /* .....#.. */

- 0x0D, /* ..##.#.. */

- 0x13, /* .#..##.. */

- 0x11, /* .#...#.. */

- 0x13, /* .#..##.. */

- 0x0D, /* ..##.#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 101, 0x65) */

- 0x00, /* ........ */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x1F, /* .#####.. */

- 0x10, /* .#...... */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 102, 0x66) */

- 0x06, /* ...##... */

- 0x09, /* ..#..#.. */

- 0x08, /* ..#..... */

- 0x1E, /* .####... */

- 0x08, /* ..#..... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 103, 0x67) */

- 0x00, /* ........ */

- 0x0D, /* ..##.#.. */

- 0x12, /* .#..#... */

- 0x0C, /* ..##.... */

- 0x10, /* .#...... */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ *//* (char = 104, 0x68) */

- 0x10, /* .#...... */

- 0x16, /* .#.##... */

- 0x19, /* .##..#.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 105, 0x69) */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x0C, /* ..##.... */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 106, 0x6a) */

- 0x02, /* ....#... */

- 0x00, /* ........ */

- 0x06, /* ...##... */

- 0x02, /* ....#... */

- 0x12, /* .#..#... */

- 0x0C, /* ..##.... */

- 0x00, /* ........ *//* (char = 107, 0x6b) */

- 0x10, /* .#...... */

- 0x11, /* .#...#.. */

- 0x12, /* .#..#... */

- 0x1C, /* .###.... */

- 0x12, /* .#..#... */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 108, 0x6c) */

- 0x0C, /* ..##.... */

- 0x04, /* ...#.... */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 109, 0x6d) */

- 0x00, /* ........ */

- 0x1A, /* .##.#... */

- 0x15, /* .#.#.#.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 110, 0x6e) */

- 0x00, /* ........ */

- 0x16, /* .#.##... */

- 0x19, /* .##..#.. */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 111, 0x6f) */

- 0x00, /* ........ */

- 0x0E, /* ..###... */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 112, 0x70) */

- 0x00, /* ........ */

- 0x16, /* .#.##... */

- 0x19, /* .##..#.. */

- 0x16, /* .#.##... */

- 0x10, /* .#...... */

- 0x00, /* ........ *//* (char = 113, 0x71) */

- 0x00, /* ........ */

- 0x0D, /* ..##.#.. */

- 0x13, /* .#..##.. */

- 0x0D, /* ..##.#.. */

- 0x01, /* .....#.. */

- 0x00, /* ........ *//* (char = 114, 0x72) */

- 0x00, /* ........ */

- 0x16, /* .#.##... */

- 0x19, /* .##..#.. */

- 0x10, /* .#...... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 115, 0x73) */

- 0x00, /* ........ */

- 0x0E, /* ..###... */

- 0x10, /* .#...... */

- 0x0E, /* ..###... */

- 0x01, /* .....#.. */

- 0x1E, /* .####... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 116, 0x74) */

- 0x08, /* ..#..... */

- 0x1E, /* .####... */

- 0x08, /* ..#..... */

- 0x09, /* ..#..#.. */

- 0x06, /* ...##... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 117, 0x75) */

- 0x00, /* ........ */

- 0x11, /* .#...#.. */

- 0x13, /* .#..##.. */

- 0x0D, /* ..##.#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 118, 0x76) */

- 0x00, /* ........ */

- 0x11, /* .#...#.. */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 119, 0x77) */

- 0x00, /* ........ */

- 0x11, /* .#...#.. */

- 0x15, /* .#.#.#.. */

- 0x0A, /* ..#.#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 120, 0x78) */

- 0x00, /* ........ */

- 0x11, /* .#...#.. */

- 0x0A, /* ..#.#... */

- 0x04, /* ...#.... */

- 0x0A, /* ..#.#... */

- 0x11, /* .#...#.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 121, 0x79) */

- 0x00, /* ........ */

- 0x11, /* .#...#.. */

- 0x13, /* .#..##.. */

- 0x0D, /* ..##.#.. */

- 0x01, /* .....#.. */

- 0x11, /* .#...#.. */

- 0x0E, /* ..###... */

- 0x00, /* ........ *//* (char = 122, 0x7a) */

- 0x00, /* ........ */

- 0x1F, /* .#####.. */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x1F, /* .#####.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 123, 0x7b) */

- 0x03, /* ....##.. */

- 0x04, /* ...#.... */

- 0x02, /* ....#... */

- 0x0C, /* ..##.... */

- 0x02, /* ....#... */

- 0x04, /* ...#.... */

- 0x03, /* ....##.. */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 124, 0x7c) */

- 0x04, /* ...#.... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 125, 0x7d) */

- 0x18, /* .##..... */

- 0x04, /* ...#.... */

- 0x08, /* ..#..... */

- 0x06, /* ...##... */

- 0x08, /* ..#..... */

- 0x04, /* ...#.... */

- 0x18, /* .##..... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 126, 0x7e) */

- 0x09, /* ..#..#.. */

- 0x15, /* .#.#.#.. */

- 0x12, /* .#..#... */

- 0x00, /* ........ */

- 0x00, /* ........ *//* (char = 127, 0x7f) */

- 0x00, /* ........ */

-};

diff --git a/sys/arch/mac68k/dev/adb.c b/sys/arch/mac68k/dev/adb.c
index e83010937ed..50531807ce1 100644
--- a/sys/arch/mac68k/dev/adb.c
+++ b/sys/arch/mac68k/dev/adb.c

@@ -1,7 +1,7 @@

-/* $OpenBSD: adb.c,v 1.14 2005/11/21 18:16:37 millert Exp $ */

-/* $NetBSD: adb.c,v 1.13 1996/12/16 16:17:02 scottr Exp $ */

+/* $OpenBSD: adb.c,v 1.15 2006/01/04 20:39:04 miod Exp $ */

+/* $NetBSD: adb.c,v 1.47 2005/06/16 22:43:36 jmc Exp $ */

-/*-

+/*

@@ -11,7 +11,7 @@

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

-e* notice, this list of conditions and the following disclaimer in the

+ * notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. All advertising materials mentioning features or use of this software

* must display the following acknowledgement:

@@ -34,531 +34,265 @@ e* notice, this list of conditions and the following disclaimer in the

#include <sys/param.h>

#include <sys/device.h>

#include <sys/fcntl.h>

-#include <sys/ioctl.h>

-#include <sys/selinfo.h>

#include <sys/poll.h>

+#include <sys/selinfo.h>

#include <sys/proc.h>

#include <sys/signalvar.h>

#include <sys/systm.h>

-#include <sys/time.h>

-#include <sys/timeout.h>

#include <machine/autoconf.h>

-#include <machine/keyboard.h>

+#include <machine/cpu.h>

-#include <arch/mac68k/mac68k/macrom.h>

-#include <arch/mac68k/dev/adbvar.h>

-#include <arch/mac68k/dev/itevar.h>

+#include <mac68k/dev/adbvar.h>

* Function declarations.

-static int adbmatch(struct device *, void *, void *);

-static void adbattach(struct device *, struct device *, void *);

+int adbmatch(struct device *, void *, void *);

+void adbattach(struct device *, struct device *, void *);

+int adbprint(void *, const char *);

+void adb_attach_deferred(void *);

+extern void adb_jadbproc(void);

* Global variables.

-int adb_polling = 0; /* Are we polling? (Debugger mode) */

+int adb_polling = 0; /* Are we polling? (Debugger mode) */

+#ifdef ADB_DEBUG

+int adb_debug = 0; /* Output debugging messages */

+#endif /* ADB_DEBUG */

+extern struct mac68k_machine_S mac68k_machine;

+extern int adbHardware;

+extern char *adbHardwareDescr[];

- * Local variables.

+ * Driver definition.

-/* External keyboard translation matrix */

-extern unsigned char keyboard[128][3];

-/* Event queue definitions */

-#if !defined(ADB_MAX_EVENTS)

-#define ADB_MAX_EVENTS 200 /* Maximum events to be kept in queue */

- /* maybe should be higher for slower macs? */

-#endif /* !defined(ADB_MAX_EVENTS) */

-static adb_event_t adb_evq[ADB_MAX_EVENTS]; /* ADB event queue */

-static int adb_evq_tail = 0; /* event queue tail */

-static int adb_evq_len = 0; /* event queue length */

-/* ADB device state information */

-static int adb_isopen = 0; /* Are we queuing events for adb_read? */

-static struct selinfo adb_selinfo; /* select() info */

-static struct proc *adb_ioproc = NULL; /* process to wakeup */

-/* Key repeat parameters */

-static int adb_rptdelay = 20; /* ticks before auto-repeat */

-static int adb_rptinterval = 6; /* ticks between auto-repeat */

-static int adb_repeating = -1; /* key that is auto-repeating */

-static adb_event_t adb_rptevent;/* event to auto-repeat */

-/* Driver definition. -- This should probably be a bus... */

struct cfattach adb_ca = {

sizeof(struct device), adbmatch, adbattach

};

struct cfdriver adb_cd = {

NULL, "adb", DV_DULL

};

-struct timeout repeat_timeout;

-static int

-adbmatch(parent, vcf, aux)

- struct device *parent;

- void *vcf;

- void *aux;

+int

+adbmatch(struct device *parent, void *vcf, void *aux)

{

- return 1;

+ static int adb_matched = 0;

+ /* Allow only one instance. */

+ if (adb_matched)

+ return (0);

+ adb_matched = 1;

+ return (1);

}

-static void

-adbattach(parent, dev, aux)

- struct device *parent, *dev;

- void *aux;

+void

+adbattach(struct device *parent, struct device *self, void *aux)

{

- printf(" (ADB event device)\n");

+ printf("\n");

+ startuphook_establish(adb_attach_deferred, self);

}

-void

-adb_enqevent(event)

- adb_event_t *event;

+void

+adb_attach_deferred(void *v)

{

- int s;

+ struct device *self = v;

+ ADBDataBlock adbdata;

+ struct adb_attach_args aa_args;

+ int totaladbs;

+ int adbindex, adbaddr;

+ printf("%s", self->dv_xname);

+ adb_polling = 1;

+#ifdef MRG_ADB

+ if (!mrg_romready()) {

+ printf(": no ROM ADB driver in this kernel for this machine\n");

+ return;

+ }

- if (adb_evq_tail < 0 || adb_evq_tail >= ADB_MAX_EVENTS)

- panic("adb: event queue tail is out of bounds");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf("adb: call mrg_initadbintr\n");

+#endif

- if (adb_evq_len < 0 || adb_evq_len > ADB_MAX_EVENTS)

- panic("adb: event queue len is out of bounds");

+ mrg_initadbintr(); /* Mac ROM Glue okay to do ROM intr */

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf("adb: returned from mrg_initadbintr\n");

+#endif

- s = splhigh();

+ /* ADBReInit pre/post-processing */

+ JADBProc = adb_jadbproc;

- if (adb_evq_len == ADB_MAX_EVENTS) {

- splx(s);

- return; /* Oh, well... */

- }

- adb_evq[(adb_evq_len + adb_evq_tail) % ADB_MAX_EVENTS] =

- *event;

- adb_evq_len++;

+ /* Initialize ADB */

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf("adb: calling ADBAlternateInit.\n");

+#endif

- selwakeup(&adb_selinfo);

- if (adb_ioproc)

- psignal(adb_ioproc, SIGIO);

+ printf(": mrg");

+ ADBAlternateInit();

+#else

+ ADBReInit();

+ printf(": %s", adbHardwareDescr[adbHardware]);

- splx(s);

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf("adb: done with ADBReInit\n");

+#endif

-void

-adb_handoff(event)

- adb_event_t *event;

- if (adb_isopen && !adb_polling) {

- adb_enqevent(event);

- } else {

- if (event->def_addr == 2)

- ite_intr(event);

- }

+#endif /* MRG_ADB */

+ totaladbs = CountADBs();

-void

-adb_autorepeat(keyp)

- void *keyp;

- int key = (int) keyp;

+ printf(", %d target%s\n", totaladbs, (totaladbs == 1) ? "" : "s");

- adb_rptevent.bytes[0] |= 0x80;

- microtime(&adb_rptevent.timestamp);

- adb_handoff(&adb_rptevent); /* do key up */

+ /* for each ADB device */

+ for (adbindex = 1; adbindex <= totaladbs; adbindex++) {

+ /* Get the ADB information */

+ adbaddr = GetIndADB(&adbdata, adbindex);

- adb_rptevent.bytes[0] &= 0x7f;

- microtime(&adb_rptevent.timestamp);

- adb_handoff(&adb_rptevent); /* do key down */

+ aa_args.origaddr = (int)(adbdata.origADBAddr);

+ aa_args.adbaddr = adbaddr;

+ aa_args.handler_id = (int)(adbdata.devType);

- if (adb_repeating == key) {

- timeout_set(&repeat_timeout, adb_autorepeat, keyp);

- timeout_add(&repeat_timeout, adb_rptinterval);

+ (void)config_found(self, &aa_args, adbprint);

}

+ adb_polling = 0;

}

-void

-adb_dokeyupdown(event)

- adb_event_t *event;

+int

+adbprint(void *args, const char *name)

{

- int adb_key;

- if (event->def_addr == 2) {

- adb_key = event->u.k.key & 0x7f;

- if (!(event->u.k.key & 0x80) &&

- keyboard[event->u.k.key & 0x7f][0] != 0) {

- /* ignore shift & control */

- if (adb_repeating != -1) {

- timeout_del(&repeat_timeout);

+ struct adb_attach_args *aa_args = (struct adb_attach_args *)args;

+ int rv = UNCONF;

+ if (name) { /* no configured device matched */

+ rv = UNSUPP; /* most ADB device types are unsupported */

+ /* print out what kind of ADB device we have found */

+ printf("%s addr %d: ", name, aa_args->adbaddr);

+ switch(aa_args->origaddr) {

+#ifdef DIAGNOSTIC

+ case ADBADDR_SECURE:

+ printf("security dongle (%d)",

+ aa_args->handler_id);

+ break;

+#endif

+ case ADBADDR_MAP:

+ printf("mapped device (%d)",

+ aa_args->handler_id);

+ rv = UNCONF;

+ break;

+ case ADBADDR_REL:

+ printf("relative positioning device (%d)",

+ aa_args->handler_id);

+ rv = UNCONF;

+ break;

+#ifdef DIAGNOSTIC

+ case ADBADDR_ABS:

+ switch (aa_args->handler_id) {

+ case ADB_ARTPAD:

+ printf("WACOM ArtPad II");

+ break;

+ default:

+ printf("absolute positioning device (%d)",

+ aa_args->handler_id);

+ break;

}

- adb_rptevent = *event;

- adb_repeating = adb_key;

- timeout_set(&repeat_timeout, adb_autorepeat,

- (caddr_t)adb_key);

- timeout_add(&repeat_timeout, adb_rptdelay);

- } else {

- if (adb_repeating != -1) {

- adb_repeating = -1;

- timeout_del(&repeat_timeout);

+ break;

+ case ADBADDR_DATATX:

+ printf("data transfer device (modem?) (%d)",

+ aa_args->handler_id);

+ break;

+ case ADBADDR_MISC:

+ switch (aa_args->handler_id) {

+ case ADB_POWERKEY:

+ printf("Sophisticated Circuits PowerKey");

+ break;

+ default:

+ printf("misc. device (remote control?) (%d)",

+ aa_args->handler_id);

+ break;

}

- adb_rptevent = *event;

- }

- adb_handoff(event);

-static int adb_ms_buttons = 0;

-void

-adb_keymaybemouse(event)

- adb_event_t *event;

- static int optionkey_down = 0;

- adb_event_t new_event;

- if (event->u.k.key == ADBK_KEYDOWN(ADBK_OPTION)) {

- optionkey_down = 1;

- } else if (event->u.k.key == ADBK_KEYUP(ADBK_OPTION)) {

- /* key up */

- optionkey_down = 0;

- if (adb_ms_buttons & 0xfe) {

- adb_ms_buttons &= 1;

- new_event.def_addr = ADBADDR_MS;

- new_event.u.m.buttons = adb_ms_buttons;

- new_event.u.m.dx = new_event.u.m.dy = 0;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- }

- } else if (optionkey_down) {

- if (event->u.k.key == ADBK_KEYDOWN(ADBK_LEFT)) {

- adb_ms_buttons |= 2; /* middle down */

- new_event.def_addr = ADBADDR_MS;

- new_event.u.m.buttons = adb_ms_buttons;

- new_event.u.m.dx = new_event.u.m.dy = 0;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- } else if (event->u.k.key == ADBK_KEYUP(ADBK_LEFT)) {

- adb_ms_buttons &= ~2; /* middle up */

- new_event.def_addr = ADBADDR_MS;

- new_event.u.m.buttons = adb_ms_buttons;

- new_event.u.m.dx = new_event.u.m.dy = 0;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- } else if (event->u.k.key == ADBK_KEYDOWN(ADBK_RIGHT)) {

- adb_ms_buttons |= 4; /* right down */

- new_event.def_addr = ADBADDR_MS;

- new_event.u.m.buttons = adb_ms_buttons;

- new_event.u.m.dx = new_event.u.m.dy = 0;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- } else if (event->u.k.key == ADBK_KEYUP(ADBK_RIGHT)) {

- adb_ms_buttons &= ~4; /* right up */

- new_event.def_addr = ADBADDR_MS;

- new_event.u.m.buttons = adb_ms_buttons;

- new_event.u.m.dx = new_event.u.m.dy = 0;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- } else if (ADBK_MODIFIER(event->u.k.key)) {

- /* ctrl, shift, cmd */

- adb_dokeyupdown(event);

- } else if (!(event->u.k.key & 0x80)) {

- /* key down */

- new_event = *event;

- /* send option-down */

- new_event.u.k.key = ADBK_KEYDOWN(ADBK_OPTION);

- new_event.bytes[0] = new_event.u.k.key;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- /* send key-down */

- new_event.u.k.key = event->bytes[0];

- new_event.bytes[0] = new_event.u.k.key;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- /* send key-up */

- new_event.u.k.key =

- ADBK_KEYUP(ADBK_KEYVAL(event->bytes[0]));

- microtime(&new_event.timestamp);

- new_event.bytes[0] = new_event.u.k.key;

- adb_dokeyupdown(&new_event);

- /* send option-up */

- new_event.u.k.key = ADBK_KEYUP(ADBK_OPTION);

- new_event.bytes[0] = new_event.u.k.key;

- microtime(&new_event.timestamp);

- adb_dokeyupdown(&new_event);

- } else {

- /* option-keyup -- do nothing. */

- }

- } else {

- adb_dokeyupdown(event);

- }

-void

-adb_processevent(event)

- adb_event_t *event;

- adb_event_t new_event;

- int i, button_bit, max_byte, mask, buttons;

- new_event = *event;

- buttons = 0;

- switch (event->def_addr) {

- case ADBADDR_KBD:

- new_event.u.k.key = event->bytes[0];

- new_event.bytes[1] = 0xff;

- adb_keymaybemouse(&new_event);

- if (event->bytes[1] != 0xff) {

- new_event.u.k.key = event->bytes[1];

- new_event.bytes[0] = event->bytes[1];

- new_event.bytes[1] = 0xff;

- adb_keymaybemouse(&new_event);

- }

- break;

- case ADBADDR_MS:

- /*

- * This should handle both plain ol' Apple mice and mice

- * that claim to support the Extended Apple Mouse Protocol.

- */

- max_byte = event->byte_count;

- button_bit = 1;

- switch (event->hand_id) {

- case ADBMS_USPEED:

- /* MicroSpeed mouse */

- if (max_byte == 4)

- buttons = (~event->bytes[2]) & 0xff;

- else

- buttons = (event->bytes[0] & 0x80) ? 0 : 1;

break;

default:

- /* Classic Mouse Protocol (up to 2 buttons) */

- for (i = 0; i < 2; i++, button_bit <<= 1)

- /* 0 when button down */

- if (!(event->bytes[i] & 0x80))

- buttons |= button_bit;

- else

- buttons &= ~button_bit;

- /* Extended Protocol (up to 6 more buttons) */

- for (mask = 0x80; i < max_byte;

- i += (mask == 0x80), button_bit <<= 1) {

- /* 0 when button down */

- if (!(event->bytes[i] & mask))

- buttons |= button_bit;

- else

- buttons &= ~button_bit;

- mask = ((mask >> 4) & 0xf)

- | ((mask & 0xf) << 4);

- }

+ printf("unknown type device, (handler %d)",

+ aa_args->handler_id);

break;

+#endif /* DIAGNOSTIC */

}

- new_event.u.m.buttons = adb_ms_buttons | buttons;

- new_event.u.m.dx = ((signed int) (event->bytes[1] & 0x3f)) -

- ((event->bytes[1] & 0x40) ? 64 : 0);

- new_event.u.m.dy = ((signed int) (event->bytes[0] & 0x3f)) -

- ((event->bytes[0] & 0x40) ? 64 : 0);

- adb_dokeyupdown(&new_event);

- break;

- default: /* God only knows. */

- adb_dokeyupdown(event);

- }

+ } else /* a device matched and was configured */

+ printf(" addr %d: ", aa_args->adbaddr);

-int

-adbopen(dev, flag, mode, p)

- dev_t dev;

- int flag, mode;

- struct proc *p;

- register int unit;

- int error = 0;

- int s;

- unit = minor(dev);

- if (unit != 0)

- return (ENXIO);

- s = splhigh();

- if (adb_isopen) {

- splx(s);

- return (EBUSY);

- }

- splx(s);

- adb_evq_tail = 0;

- adb_evq_len = 0;

- adb_isopen = 1;

- adb_ioproc = p;

- return (error);

-int

-adbclose(dev, flag, mode, p)

- dev_t dev;

- int flag, mode;

- struct proc *p;

- adb_isopen = 0;

- adb_ioproc = NULL;

- return (0);

-int

-adbread(dev, uio, flag)

- dev_t dev;

- struct uio *uio;

- int flag;

- int s, error;

- int willfit;

- int total;

- int firstmove;

- int moremove;

- if (uio->uio_resid < sizeof(adb_event_t))

- return (EMSGSIZE); /* close enough. */

- s = splhigh();

- if (adb_evq_len == 0) {

- splx(s);

- return (0);

- }

- willfit = howmany(uio->uio_resid, sizeof(adb_event_t));

- total = (adb_evq_len < willfit) ? adb_evq_len : willfit;

- firstmove = (adb_evq_tail + total > ADB_MAX_EVENTS)

- ? (ADB_MAX_EVENTS - adb_evq_tail) : total;

- error = uiomove((caddr_t) & adb_evq[adb_evq_tail],

- firstmove * sizeof(adb_event_t), uio);

- if (error) {

- splx(s);

- return (error);

- }

- moremove = total - firstmove;

- if (moremove > 0) {

- error = uiomove((caddr_t) & adb_evq[0],

- moremove * sizeof(adb_event_t), uio);

- if (error) {

- splx(s);

- return (error);

- }

- adb_evq_tail = (adb_evq_tail + total) % ADB_MAX_EVENTS;

- adb_evq_len -= total;

- splx(s);

- return (0);

-int

-adbwrite(dev, uio, flag)

- dev_t dev;

- struct uio *uio;

- int flag;

- return 0;

+ return (rv);

}

-int

-adbioctl(dev, cmd, data, flag, p)

- dev_t dev;

- int cmd;

- caddr_t data;

- int flag;

- struct proc *p;

+/*

+ * adb_op_sync

+ *

+ * This routine does exactly what the adb_op routine does, except that after

+ * the adb_op is called, it waits until the return value is present before

+ * returning.

+ *

+ * NOTE: The user specified compRout is ignored, since this routine specifies

+ * it's own to adb_op, which is why you really called this in the first place

+ * anyway.

+ */

+int

+adb_op_sync(Ptr buffer, Ptr compRout, Ptr data, short command)

{

- switch (cmd) {

- case ADBIOC_DEVSINFO: {

- adb_devinfo_t *di;

- ADBDataBlock adbdata;

- int totaldevs;

- int adbaddr;

- int i;

- di = (void *) data;

- /* Initialize to no devices */

- for (i = 0; i < 16; i++)

- di->dev[i].addr = -1;

- totaldevs = CountADBs();

- for (i = 1; i <= totaldevs; i++) {

- adbaddr = GetIndADB(&adbdata, i);

- di->dev[adbaddr].addr = adbaddr;

- di->dev[adbaddr].default_addr = adbdata.origADBAddr;

- di->dev[adbaddr].handler_id = adbdata.devType;

- }

- /* Must call ADB Manager to get devices now */

- break;

- }

- case ADBIOC_GETREPEAT:{

- adb_rptinfo_t *ri;

- ri = (void *) data;

- ri->delay_ticks = adb_rptdelay;

- ri->interval_ticks = adb_rptinterval;

- break;

- }

- case ADBIOC_SETREPEAT:{

- adb_rptinfo_t *ri;

- ri = (void *) data;

- adb_rptdelay = ri->delay_ticks;

- adb_rptinterval = ri->interval_ticks;

- break;

- }

+ int tmout;

+ int result;

+ volatile int flag = 0;

- case ADBIOC_RESET:

- adb_init();

- break;

- case ADBIOC_LISTENCMD:{

- adb_listencmd_t *lc;

+ result = ADBOp(buffer, (void *)adb_op_comprout, (Ptr)&flag,

+ command); /* send command */

+ if (result == 0) { /* send ok? */

+ /*

+ * Total time to wait is calculated as follows:

+ * - Tlt (stop to start time): 260 usec

+ * - start bit: 100 usec

+ * - up to 8 data bytes: 64 * 100 usec = 6400 usec

+ * - stop bit (with SRQ): 140 usec

+ * Total: 6900 usec

+ *

+ * This is the total time allowed by the specification. Any

+ * device that doesn't conform to this will fail to operate

+ * properly on some Apple systems. In spite of this we

+ * double the time to wait; some Cuda-based apparently

+ * queues some commands and allows the main CPU to continue

+ * processing (radical concept, eh?). To be safe, allow

+ * time for two complete ADB transactions to occur.

+ */

+ for (tmout = 13800; !flag && tmout >= 10; tmout -= 10)

+ delay(10);

+ if (!flag && tmout > 0)

+ delay(tmout);

- lc = (void *) data;

+ if (!flag)

+ result = -2;

}

- default:

- return (EINVAL);

- }

- return (0);

+ return result;

}

-int

-adbpoll(dev, events, p)

- dev_t dev;

- int events;

- struct proc *p;

+/*

+ * adb_op_comprout

+ *

+ * This function is used by the adb_op_sync routine so it knows when the

+ * function is done.

+ */

+void

+adb_op_comprout(void)

{

- int revents = 0;

- if (events & (POLLIN | POLLRDNORM)) {

- /* succeed if there is something to read */

- if (adb_evq_len > 0)

- revents |= events & (POLLIN | POLLRDNORM);

- else

- selrecord(p, &adb_selinfo);

- }

- if (events & (POLLOUT | POLLWRNORM)) {

- /* always fails => never blocks */

- revents |= events & (POLLOUT | POLLWRNORM);

- }

- return (revents);

+ asm("movw #1,a2@ | update flag value");

}

diff --git a/sys/arch/mac68k/dev/adb_direct.c b/sys/arch/mac68k/dev/adb_direct.c
index f6f747ca974..70bb750fe58 100644
--- a/sys/arch/mac68k/dev/adb_direct.c
+++ b/sys/arch/mac68k/dev/adb_direct.c

@@ -1,7 +1,7 @@

-/* $OpenBSD: adb_direct.c,v 1.15 2004/11/26 21:21:23 miod Exp $ */

-/* $NetBSD: adb_direct.c,v 1.5 1997/04/21 18:04:28 scottr Exp $ */

+/* $OpenBSD: adb_direct.c,v 1.16 2006/01/04 20:39:04 miod Exp $ */

+/* $NetBSD: adb_direct.c,v 1.51 2005/06/16 22:43:36 jmc Exp $ */

-/* From: adb_direct.c 2.02 4/18/97 jpw */

+/* From: adb_direct.c 2.02 4/18/97 jpw */

@@ -33,38 +33,58 @@

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-/* This code is rather messy, but I don't have time right now

+/*

+ * This code is rather messy, but I don't have time right now

* to clean it up as much as I would like.

- * But it works, so I'm happy. :-) jpw */

+ * But it works, so I'm happy. :-) jpw

+ */

+/*

+ * TO DO:

+ * - We could reduce the time spent in the adb_intr_* routines

+ * by having them save the incoming and outgoing data directly

+ * in the adbInbound and adbOutbound queues, as it would reduce

+ * the number of times we need to copy the data around. It

+ * would also make the code more readable and easier to follow.

+ * - (Related to above) Use the header part of adbCommand to

+ * reduce the number of copies we have to do of the data.

+ * - (Related to above) Actually implement the adbOutbound queue.

+ * This is fairly easy once you switch all the intr routines

+ * over to using adbCommand structs directly.

+ * - There is a bug in the state machine of adb_intr_cuda

+ * code that causes hangs, especially on 030 machines, probably

+ * because of some timing issues. Because I have been unable to

+ * determine the exact cause of this bug, I used the timeout function

+ * to check for and recover from this condition. If anyone finds

+ * the actual cause of this bug, the calls to timeout and the

+ * adb_cuda_tickle routine can be removed.

+ */

#if defined(__NetBSD__) || defined(__OpenBSD__)

#include <sys/param.h>

#include <sys/cdefs.h>

+#include <sys/pool.h>

+#include <sys/queue.h>

#include <sys/systm.h>

+#include <sys/timeout.h>

#include <machine/viareg.h>

#include <machine/param.h>

#include <machine/cpu.h>

-#include <machine/adbsys.h> /* required for adbvar.h */

-#include <arch/mac68k/mac68k/macrom.h>

-#include "adbvar.h"

+#include <mac68k/dev/adbvar.h>

#define printf_intr printf

-#else

+#else /* !__NetBSD__, i.e. Mac OS */

#include "via.h" /* for macos based testing */

-typedef unsigned char u_char;

-#endif

-#ifdef MRG_ADB

-int adb_poweroff(void);

-int adb_read_date_time(unsigned long *t);

-int adb_set_date_time(unsigned long t);

-#endif

+/* #define ADB_DEBUG */ /* more verbose for testing */

-/* more verbose for testing */

-/*#define DEBUG*/

+/* Types of ADB hardware that we support */

+#define ADB_HW_UNKNOWN 0x0 /* don't know */

+#define ADB_HW_II 0x1 /* Mac II series */

+#define ADB_HW_IISI 0x2 /* Mac IIsi series */

+#define ADB_HW_PB 0x3 /* PowerBook series */

+#define ADB_HW_CUDA 0x4 /* Machines with a Cuda chip */

+#endif /* __NetBSD__ */

/* some misc. leftovers */

#define vPB 0x0000

@@ -74,31 +94,25 @@ int adb_set_date_time(unsigned long t);

#define vSR_INT 0x04

#define vSR_OUT 0x10

-/* types of adb hardware that we (will eventually) support */

-#define ADB_HW_UNKNOWN 0x01 /* don't know */

-#define ADB_HW_II 0x02 /* Mac II series */

-#define ADB_HW_IISI 0x03 /* Mac IIsi series */

-#define ADB_HW_PB 0x04 /* PowerBook series */

-#define ADB_HW_CUDA 0x05 /* Machines with a Cuda chip */

/* the type of ADB action that we are currently preforming */

-#define ADB_ACTION_NOTREADY 0x01 /* has not been initialized yet */

-#define ADB_ACTION_IDLE 0x02 /* the bus is currently idle */

-#define ADB_ACTION_OUT 0x03 /* sending out a command */

-#define ADB_ACTION_IN 0x04 /* receiving data */

+#define ADB_ACTION_NOTREADY 0x1 /* has not been initialized yet */

+#define ADB_ACTION_IDLE 0x2 /* the bus is currently idle */

+#define ADB_ACTION_OUT 0x3 /* sending out a command */

+#define ADB_ACTION_IN 0x4 /* receiving data */

+#define ADB_ACTION_POLLING 0x5 /* polling - II only */

* These describe the state of the ADB bus itself, although they

* don't necessarily correspond directly to ADB states.

* Note: these are not really used in the IIsi code.

-#define ADB_BUS_UNKNOWN 0x01 /* we don't know yet - all models */

-#define ADB_BUS_IDLE 0x02 /* bus is idle - all models */

-#define ADB_BUS_CMD 0x03 /* starting a command - II models */

-#define ADB_BUS_ODD 0x04 /* the "odd" state - II models */

-#define ADB_BUS_EVEN 0x05 /* the "even" state - II models */

-#define ADB_BUS_ACTIVE 0x06 /* active state - IIsi models */

-#define ADB_BUS_ACK 0x07 /* currently ACKing - IIsi models */

+#define ADB_BUS_UNKNOWN 0x1 /* we don't know yet - all models */

+#define ADB_BUS_IDLE 0x2 /* bus is idle - all models */

+#define ADB_BUS_CMD 0x3 /* starting a command - II models */

+#define ADB_BUS_ODD 0x4 /* the "odd" state - II models */

+#define ADB_BUS_EVEN 0x5 /* the "even" state - II models */

+#define ADB_BUS_ACTIVE 0x6 /* active state - IIsi models */

+#define ADB_BUS_ACK 0x7 /* currently ACKing - IIsi models */

* Shortcuts for setting or testing the VIA bit states.

@@ -111,7 +125,7 @@ int adb_set_date_time(unsigned long t);

#define ADB_SET_STATE_EVEN() via_reg(VIA1, vBufB) = ((via_reg(VIA1, \

vBufB) | vPB4) & ~vPB5)

#define ADB_SET_STATE_ODD() via_reg(VIA1, vBufB) = ((via_reg(VIA1, \

- vBufB) | vPB5) & ~vPB4 )

+ vBufB) | vPB5) & ~vPB4)

#define ADB_SET_STATE_ACTIVE() via_reg(VIA1, vBufB) |= vPB5

#define ADB_SET_STATE_INACTIVE() via_reg(VIA1, vBufB) &= ~vPB5

#define ADB_SET_STATE_TIP() via_reg(VIA1, vBufB) &= ~vPB5

@@ -144,7 +158,11 @@ int adb_set_date_time(unsigned long t);

* Maximum ADB message length; includes space for data, result, and

* device code - plus a little for safety.

-#define MAX_ADB_MSG_LENGTH 20

+#define ADB_MAX_MSG_LENGTH 16

+#define ADB_MAX_HDR_LENGTH 8

+#define ADB_QUEUE 32

+#define ADB_TICKLE_TICKS 4

* A structure for storing information about each ADB device.

@@ -152,22 +170,49 @@ int adb_set_date_time(unsigned long t);

struct ADBDevEntry {

void (*ServiceRtPtr)(void);

void *DataAreaAddr;

- char devType;

- char origAddr;

- char currentAddr;

+ int devType;

+ int origAddr;

+ int currentAddr;

};

* Used to hold ADB commands that are waiting to be sent out.

struct adbCmdHoldEntry {

- u_char outBuf[MAX_ADB_MSG_LENGTH]; /* our message */

+ u_char outBuf[ADB_MAX_MSG_LENGTH]; /* our message */

u_char *saveBuf; /* buffer to know where to save result */

u_char *compRout; /* completion routine pointer */

u_char *data; /* completion routine data pointer */

};

+ * Eventually used for two separate queues, the queue between

+ * the upper and lower halves, and the outgoing packet queue.

+ * TO DO: adbCommand can replace all of adbCmdHoldEntry eventually

+ */

+struct adbCommand {

+ u_char header[ADB_MAX_HDR_LENGTH]; /* not used yet */

+ u_char data[ADB_MAX_MSG_LENGTH]; /* packet data only */

+ u_char *saveBuf; /* where to save result */

+ u_char *compRout; /* completion routine pointer */

+ u_char *compData; /* completion routine data pointer */

+ u_int cmd; /* the original command for this data */

+ u_int unsol; /* 1 if packet was unsolicited */

+ u_int ack_only; /* 1 for no special processing */

+};

+/*

+ * Text representations of each hardware class

+ */

+const char *adbHardwareDescr[MAX_ADB_HW + 1] = {

+ "unknown",

+ "II series",

+ "IIsi series",

+ "PowerBook",

+ "Cuda",

+};

+/*

* A few variables that we need and their initial values.

int adbHardware = ADB_HW_UNKNOWN;

@@ -177,11 +222,12 @@ int adbWaiting = 0; /* waiting for return data from the device */

int adbWriteDelay = 0; /* working on (or waiting to do) a write */

int adbOutQueueHasData = 0; /* something in the queue waiting to go out */

int adbNextEnd = 0; /* the next incoming bute is the last (II) */

+int adbSoftPower = 0; /* machine supports soft power */

int adbWaitingCmd = 0; /* ADB command we are waiting for */

-u_char *adbBuffer = (long) 0; /* pointer to user data area */

-void *adbCompRout = (long) 0; /* pointer to the completion routine */

-void *adbCompData = (long) 0; /* pointer to the completion routine data */

+u_char *adbBuffer = (long)0; /* pointer to user data area */

+void *adbCompRout = (long)0; /* pointer to the completion routine */

+void *adbCompData = (long)0; /* pointer to the completion routine data */

long adbFakeInts = 0; /* keeps track of fake ADB interrupts for

* timeouts (II) */

int adbStarting = 1; /* doing ADBReInit so do polling differently */

@@ -190,8 +236,8 @@ int adbSendTalk = 0; /* the intr routine is sending the talk, not

int adbPolling = 0; /* we are polling for service request */

int adbPollCmd = 0; /* the last poll command we sent */

-u_char adbInputBuffer[MAX_ADB_MSG_LENGTH]; /* data input buffer */

-u_char adbOutputBuffer[MAX_ADB_MSG_LENGTH]; /* data output buffer */

+u_char adbInputBuffer[ADB_MAX_MSG_LENGTH]; /* data input buffer */

+u_char adbOutputBuffer[ADB_MAX_MSG_LENGTH]; /* data output buffer */

struct adbCmdHoldEntry adbOutQueue; /* our 1 entry output queue */

int adbSentChars = 0; /* how many characters we have sent */

@@ -199,30 +245,50 @@ int adbLastDevice = 0; /* last ADB dev we heard from (II ONLY) */

int adbLastDevIndex = 0; /* last ADB dev loc in dev table (II ONLY) */

int adbLastCommand = 0; /* the last ADB command we sent (II) */

-struct ADBDevEntry ADBDevTable[16]; /* our ADB device table */

+struct ADBDevEntry ADBDevTable[16]; /* our ADB device table */

int ADBNumDevices; /* num. of ADB devices found with ADBReInit */

+struct adbCommand adbInbound[ADB_QUEUE]; /* incoming queue */

+volatile int adbInCount = 0; /* how many packets in in queue */

+int adbInHead = 0; /* head of in queue */

+int adbInTail = 0; /* tail of in queue */

+struct adbCommand adbOutbound[ADB_QUEUE]; /* outgoing queue - not used yet */

+int adbOutCount = 0; /* how many packets in out queue */

+int adbOutHead = 0; /* head of out queue */

+int adbOutTail = 0; /* tail of out queue */

+int tickle_count = 0; /* how many tickles seen for this packet? */

+int tickle_serial = 0; /* the last packet tickled */

+int adb_cuda_serial = 0; /* the current packet */

+struct timeout adb_cuda_timeout;

extern struct mac68k_machine_S mac68k_machine;

void pm_setup_adb(void);

+void pm_hw_setup(void);

void pm_check_adb_devices(int);

-void pm_intr(void);

+void pm_intr(void *);

int pm_adb_op(u_char *, void *, void *, int);

void pm_init_adb_device(void);

* The following are private routines.

+#ifdef ADB_DEBUG

void print_single(u_char *);

-void adb_intr(void);

-void adb_intr_II(void);

-void adb_intr_IIsi(void);

-void adb_intr_cuda(void);

+#endif

+int adb_intr(void *);

+int adb_intr_II(void *);

+int adb_intr_IIsi(void *);

+int adb_intr_cuda(void *);

+void adb_soft_intr(void);

int send_adb_II(u_char *, u_char *, void *, void *, int);

int send_adb_IIsi(u_char *, u_char *, void *, void *, int);

int send_adb_cuda(u_char *, u_char *, void *, void *, int);

void adb_intr_cuda_test(void);

-void adb_handle_unsol(u_char *);

+void adb_cuda_tickle(void);

+void adb_pass_up(struct adbCommand *);

void adb_op_comprout(void);

void adb_reinit(void);

int count_adbs(void);

@@ -231,11 +297,9 @@ int get_adb_info(ADBDataBlock *, int);

int set_adb_info(ADBSetInfoBlock *, int);

void adb_setup_hw_type(void);

int adb_op(Ptr, Ptr, Ptr, short);

-void adb_handle_unsol(u_char *);

-int adb_op_sync(Ptr, Ptr, Ptr, short);

void adb_read_II(u_char *);

-void adb_cleanup(u_char *);

-void adb_cleanup_IIsi(u_char *);

+void adb_hw_setup(void);

+void adb_hw_setup_IIsi(u_char *);

void adb_comp_exec(void);

int adb_cmd_result(u_char *);

int adb_cmd_extra(u_char *);

@@ -245,6 +309,7 @@ int adb_prog_switch_disable(void);

/* we should create this and it will be the public version */

int send_adb(u_char *, void *, void *);

+#ifdef ADB_DEBUG

* print_single

* Diagnostic display routine. Displays the hex values of the

@@ -252,64 +317,97 @@ int send_adb(u_char *, void *, void *);

* is in [0].

void

-print_single(thestring)

- u_char *thestring;

+print_single(u_char *str)

{

int x;

- if ((int) (thestring[0]) == 0) {

- printf_intr("nothing returned\n");

+ if (str == 0) {

+ printf_intr("no data - null pointer\n");

return;

}

- if (thestring == 0) {

- printf_intr("no data - null pointer\n");

+ if (*str == 0) {

+ printf_intr("nothing returned\n");

return;

}

- if (thestring[0] > 20) {

+ if (*str > 20) {

printf_intr("ADB: ACK > 20 no way!\n");

- thestring[0] = 20;

+ *str = (u_char)20;

}

- printf_intr("(length=0x%x):", thestring[0]);

- for (x = 0; x < thestring[0]; x++)

- printf_intr(" 0x%02x", thestring[x + 1]);

+ printf_intr("(length=0x%x):", (u_int)*str);

+ for (x = 1; x <= *str; x++)

+ printf_intr(" 0x%02x", (u_int)*(str + x));

printf_intr("\n");

}

+#endif

+void

+adb_cuda_tickle(void)

+ volatile int s;

+ if (adbActionState == ADB_ACTION_IN) {

+ if (tickle_serial == adb_cuda_serial) {

+ if (++tickle_count > 0) {

+ s = splhigh();

+ adbActionState = ADB_ACTION_IDLE;

+ adbInputBuffer[0] = 0;

+ ADB_SET_STATE_IDLE_CUDA();

+ splx(s);

+ }

+ } else {

+ tickle_serial = adb_cuda_serial;

+ tickle_count = 0;

+ }

+ } else {

+ tickle_serial = adb_cuda_serial;

+ tickle_count = 0;

+ }

+ timeout_add(&adb_cuda_timeout, ADB_TICKLE_TICKS);

* called when when an adb interrupt happens

* Cuda version of adb_intr

- * TO DO: do we want to add some zshard calls in here?

+ * TO DO: do we want to add some calls to intr_dispatch() here to

+ * grab serial interrupts?

-void

-adb_intr_cuda(void)

+int

+adb_intr_cuda(void *arg)

{

- int i, ending, len;

- unsigned int s;

+ volatile int i, ending;

+ volatile unsigned int s;

+ struct adbCommand packet;

s = splhigh(); /* can't be too careful - might be called */

/* from a routine, NOT an interrupt */

ADB_VIA_CLR_INTR(); /* clear interrupt */

ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */

switch_start:

switch (adbActionState) {

case ADB_ACTION_IDLE:

- /* This is an unexpected packet, so grab the first (dummy)

+ /*

+ * This is an unexpected packet, so grab the first (dummy)

* byte, set up the proper vars, and tell the chip we are

- * starting to receive the packet by setting the TIP bit. */

+ * starting to receive the packet by setting the TIP bit.

+ */

adbInputBuffer[1] = ADB_SR();

- ADB_SET_STATE_TIP();

+ adb_cuda_serial++;

+ if (ADB_INTR_IS_OFF) /* must have been a fake start */

+ break;

ADB_SET_SR_INPUT();

- delay(ADB_DELAY); /* required delay */

-#ifdef DEBUG

- printf_intr("idle 0x%02x ", adbInputBuffer[1]);

-#endif

+ ADB_SET_STATE_TIP();

adbInputBuffer[0] = 1;

adbActionState = ADB_ACTION_IN;

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("idle 0x%02x ", adbInputBuffer[1]);

+#endif

break;

case ADB_ACTION_IN:

@@ -320,72 +418,54 @@ switch_start:

else

ending = 0;

- /* if the second byte is 0xff, it's a "dummy" packet */

- if (adbInputBuffer[2] == 0xff)

- ending = 1;

if (1 == ending) { /* end of message? */

-#ifdef DEBUG

- printf_intr("in end 0x%02x ",

- adbInputBuffer[adbInputBuffer[0]]);

- print_single(adbInputBuffer);

+#ifdef ADB_DEBUG

+ if (adb_debug) {

+ printf_intr("in end 0x%02x ",

+ adbInputBuffer[adbInputBuffer[0]]);

+ print_single(adbInputBuffer);

+ }

#endif

- /* Are we waiting AND does this packet match what we

+ /*

+ * Are we waiting AND does this packet match what we

* are waiting for AND is it coming from either the

* ADB or RTC/PRAM sub-device? This section _should_

* recognize all ADB and RTC/PRAM type commands, but

* there may be more... NOTE: commands are always at

- * [4], even for RTC/PRAM commands. */

+ * [4], even for RTC/PRAM commands.

+ */

+ /* set up data for adb_pass_up */

+ memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);

if ((adbWaiting == 1) &&

(adbInputBuffer[4] == adbWaitingCmd) &&

((adbInputBuffer[2] == 0x00) ||

(adbInputBuffer[2] == 0x01))) {

+ packet.saveBuf = adbBuffer;

+ packet.compRout = adbCompRout;

+ packet.compData = adbCompData;

+ packet.unsol = 0;

+ packet.ack_only = 0;

+ adb_pass_up(&packet);

- if (adbBuffer != (long) 0) {

- /* if valid return data pointer */

- /* get return length minus extras */

- len = adbInputBuffer[0] - 4;

- /*

- * If adb_op is ever made to be called

- * from a user routine, we should use

- * a copyout or copyin here to be sure

- * we're in the correct context

- */

- for (i = 1; i <= len; i++)

- adbBuffer[i] = adbInputBuffer[4 + i];

- if (len < 0)

- len = 0;

- adbBuffer[0] = len;

- }

- /* call completion routine and clean up */

- adb_comp_exec();

- adbWaitingCmd = 0;

+ adbWaitingCmd = 0; /* reset "waiting" vars */

adbWaiting = 0;

- adbBuffer = (long) 0;

- adbCompRout = (long) 0;

- adbCompData = (long) 0;

+ adbBuffer = (long)0;

+ adbCompRout = (long)0;

+ adbCompData = (long)0;

} else {

- /*

- * This was an unsolicited packet, so

- * pass the data off to the handler for

- * this device if we are NOT doing this

- * during a ADBReInit.

- * This section IGNORES all data that is not

- * from the ADB sub-device. That is, not from

- * RTC or PRAM. Maybe we should fix later,

- * but do the other devices every send things

- * without being asked?

- */

- if (adbStarting == 0)

- if (adbInputBuffer[2] == 0x00)

- adb_handle_unsol(adbInputBuffer);

+ packet.unsol = 1;

+ packet.ack_only = 0;

+ adb_pass_up(&packet);

}

/* reset vars and signal the end of this frame */

adbActionState = ADB_ACTION_IDLE;

adbInputBuffer[0] = 0;

ADB_SET_STATE_IDLE_CUDA();

+ /*ADB_SET_SR_INPUT();*/

* If there is something waiting to be sent out,

@@ -395,9 +475,6 @@ switch_start:

delay(ADB_DELAY); /* required */

adbSentChars = 0;

adbActionState = ADB_ACTION_OUT;

-/* TO DO: don't we need to set up adbWaiting vars here??? */

* If the interrupt is on, we were too slow

* and the chip has already started to send

@@ -405,8 +482,8 @@ switch_start:

* and start a read cycle.

if (ADB_INTR_IS_ON) {

- ADB_SET_STATE_IDLE_CUDA();

ADB_SET_SR_INPUT();

+ ADB_SET_STATE_IDLE_CUDA();

adbSentChars = 0;

adbActionState = ADB_ACTION_IDLE;

adbInputBuffer[0] = 0;

@@ -417,33 +494,35 @@ switch_start:

* so load the first byte and tell the chip

* we want to send.

+ ADB_SET_STATE_TIP();

ADB_SET_SR_OUTPUT();

ADB_SR() = adbOutputBuffer[adbSentChars + 1];

- ADB_SET_STATE_TIP();

}

} else {

ADB_TOGGLE_STATE_ACK_CUDA();

-#ifdef DEBUG

- printf_intr("in 0x%02x ",

- adbInputBuffer[adbInputBuffer[0]]);

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("in 0x%02x ",

+ adbInputBuffer[adbInputBuffer[0]]);

#endif

}

break;

case ADB_ACTION_OUT:

i = ADB_SR(); /* reset SR-intr in IFR */

-#ifdef DEBUG

- printf_intr("intr out 0x%02x ", i);

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("intr out 0x%02x ", i);

#endif

- ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

adbSentChars++;

if (ADB_INTR_IS_ON) { /* ADB intr low during write */

-#ifdef DEBUG

- printf_intr("intr was on ");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("intr was on ");

#endif

- ADB_SET_STATE_IDLE_CUDA();

ADB_SET_SR_INPUT(); /* make sure SR is set to IN */

+ ADB_SET_STATE_IDLE_CUDA();

adbSentChars = 0; /* must start all over */

adbActionState = ADB_ACTION_IDLE; /* new state */

adbInputBuffer[0] = 0;

@@ -459,63 +538,82 @@ switch_start:

* back? */

adbWaiting = 1; /* signal waiting for return */

adbWaitingCmd = adbOutputBuffer[2]; /* save waiting command */

- } else {/* no talk, so done */

- adb_comp_exec(); /* call completion

- * routine */

- adbWaitingCmd = 0; /* reset "waiting" vars,

- * just in case */

- adbBuffer = (long) 0;

- adbCompRout = (long) 0;

- adbCompData = (long) 0;

+ } else { /* no talk, so done */

+ /* set up stuff for adb_pass_up */

+ memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);

+ packet.saveBuf = adbBuffer;

+ packet.compRout = adbCompRout;

+ packet.compData = adbCompData;

+ packet.cmd = adbWaitingCmd;

+ packet.unsol = 0;

+ packet.ack_only = 1;

+ adb_pass_up(&packet);

+ /* reset "waiting" vars, just in case */

+ adbWaitingCmd = 0;

+ adbBuffer = (long)0;

+ adbCompRout = (long)0;

+ adbCompData = (long)0;

}

adbWriteDelay = 0; /* done writing */

adbActionState = ADB_ACTION_IDLE; /* signal bus is idle */

+ ADB_SET_SR_INPUT();

ADB_SET_STATE_IDLE_CUDA();

-#ifdef DEBUG

- printf_intr("write done ");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("write done ");

#endif

} else {

ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* send next byte */

ADB_TOGGLE_STATE_ACK_CUDA(); /* signal byte ready to

* shift */

-#ifdef DEBUG

- printf_intr("toggle ");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("toggle ");

#endif

}

break;

case ADB_ACTION_NOTREADY:

- printf_intr("adb: not yet initialized\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: not yet initialized\n");

+#endif

break;

default:

- printf_intr("intr: unknown ADB state\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("intr: unknown ADB state\n");

+#endif

+ break;

}

ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */

splx(s); /* restore */

- return;

-} /* end adb_intr_IIsi */

+ return (1);

+} /* end adb_intr_cuda */

int

-send_adb_cuda(u_char * in, u_char * buffer, void *compRout, void *data, int

+send_adb_cuda(u_char *in, u_char *buffer, void *compRout, void *data, int

command)

{

- int i, s, len;

+ int s, len;

-#ifdef DEBUG

- printf_intr("SEND\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("SEND\n");

#endif

if (adbActionState == ADB_ACTION_NOTREADY)

return 1;

- s = splhigh(); /* don't interrupt while we are messing with

- * the ADB */

+ /* Don't interrupt while we are messing with the ADB */

+ s = splhigh();

if ((adbActionState == ADB_ACTION_IDLE) && /* ADB available? */

(ADB_INTR_IS_OFF)) { /* and no incoming interrupt? */

@@ -528,13 +626,16 @@ send_adb_cuda(u_char * in, u_char * buffer, void *compRout, void *data, int

return 1; /* really busy! */

}

-#ifdef DEBUG

- printf_intr("QUEUE\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("QUEUE\n");

#endif

- if ((long) in == (long) 0) { /* need to convert? */

- /* don't need to use adb_cmd_extra here because this section

- * will be called */

- /* ONLY when it is an ADB command (no RTC or PRAM) */

+ if ((long)in == (long)0) { /* need to convert? */

+ /*

+ * Don't need to use adb_cmd_extra here because this section

+ * will be called ONLY when it is an ADB command (no RTC or

+ * PRAM)

+ */

if ((command & 0x0c) == 0x08) /* copy addl data ONLY if

* doing a listen! */

len = buffer[0]; /* length of additional data */

@@ -544,14 +645,13 @@ send_adb_cuda(u_char * in, u_char * buffer, void *compRout, void *data, int

adbOutputBuffer[0] = 2 + len; /* dev. type + command + addl.

* data */

adbOutputBuffer[1] = 0x00; /* mark as an ADB command */

- adbOutputBuffer[2] = (u_char) command; /* load command */

+ adbOutputBuffer[2] = (u_char)command; /* load command */

- for (i = 1; i <= len; i++) /* copy additional output

- * data, if any */

- adbOutputBuffer[2 + i] = buffer[i];

+ /* copy additional output data, if any */

+ memcpy(adbOutputBuffer + 3, buffer + 1, len);

} else

- for (i = 0; i <= (adbOutputBuffer[0] + 1); i++)

- adbOutputBuffer[i] = in[i];

+ /* if data ready, just copy over */

+ memcpy(adbOutputBuffer, in, in[0] + 2);

adbSentChars = 0; /* nothing sent yet */

adbBuffer = buffer; /* save buffer to know where to save result */

@@ -560,8 +660,9 @@ send_adb_cuda(u_char * in, u_char * buffer, void *compRout, void *data, int

adbWaitingCmd = adbOutputBuffer[2]; /* save wait command */

if (adbWriteDelay != 1) { /* start command now? */

-#ifdef DEBUG

- printf_intr("out start NOW");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("out start NOW");

#endif

delay(ADB_DELAY);

adbActionState = ADB_ACTION_OUT; /* set next state */

@@ -574,24 +675,26 @@ send_adb_cuda(u_char * in, u_char * buffer, void *compRout, void *data, int

splx(s);

- if (0x0100 <= (s & 0x0700)) /* were VIA1 interrupts blocked ? */

+ if (0x0100 <= (s & 0x0700)) /* were VIA1 interrupts blocked? */

/* poll until byte done */

while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)

|| (adbWaiting == 1))

- if (ADB_SR_INTR_IS_ON) /* wait for "interrupt" */

- adb_intr_cuda(); /* go process

- * "interrupt" */

+ if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */

+ adb_intr_cuda(NULL); /* go process it */

+ if (adb_polling)

+ adb_soft_intr();

+ }

return 0;

} /* send_adb_cuda */

-/* TO DO: add one or two zshard calls in here */

-void

-adb_intr_II(void)

+int

+adb_intr_II(void *arg)

{

- int i, len, intr_on = 0;

- int send = 0, do_srq = 0;

+ struct adbCommand packet;

+ int i, intr_on = 0;

+ int send = 0;

unsigned int s;

s = splhigh(); /* can't be too careful - might be called */

@@ -601,24 +704,73 @@ adb_intr_II(void)

ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */

-/*if (ADB_INTR_IS_ON)*/

-/* printf_intr("INTR ON ");*/

+ delay(ADB_DELAY); /* yuck (don't remove) */

+ (void)intr_dispatch(0x70); /* grab any serial interrupts */

if (ADB_INTR_IS_ON)

intr_on = 1; /* save for later */

+switch_start:

switch (adbActionState) {

+ case ADB_ACTION_POLLING:

+ if (!intr_on) {

+ if (adbOutQueueHasData) {

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("POLL-doing-out-queue. ");

+#endif

+ ADB_SET_STATE_IDLE_II();

+ delay(ADB_DELAY);

+ /* copy over data */

+ memcpy(adbOutputBuffer, adbOutQueue.outBuf,

+ adbOutQueue.outBuf[0] + 2);

+ adbBuffer = adbOutQueue.saveBuf; /* user data area */

+ adbCompRout = adbOutQueue.compRout; /* completion routine */

+ adbCompData = adbOutQueue.data; /* comp. rout. data */

+ adbOutQueueHasData = 0; /* currently processing

+ * "queue" entry */

+ adbSentChars = 0; /* nothing sent yet */

+ adbActionState = ADB_ACTION_OUT; /* set next state */

+ ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

+ ADB_SR() = adbOutputBuffer[1]; /* load byte for output */

+ adbBusState = ADB_BUS_CMD; /* set bus to cmd state */

+ ADB_SET_STATE_CMD(); /* tell ADB that we want to send */

+ break;

+ } else {

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("pIDLE ");

+#endif

+ adbActionState = ADB_ACTION_IDLE;

+ }

+ } else {

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("pIN ");

+#endif

+ adbActionState = ADB_ACTION_IN;

+ }

+ delay(ADB_DELAY);

+ (void)intr_dispatch(0x70); /* grab any serial interrupts */

+ goto switch_start;

+ break;

case ADB_ACTION_IDLE:

if (!intr_on) {

- /* printf_intr("FAKE DROPPED \n"); */

- /* printf_intr(" XX "); */

i = ADB_SR();

+ adbBusState = ADB_BUS_IDLE;

+ adbActionState = ADB_ACTION_IDLE;

+ ADB_SET_STATE_IDLE_II();

break;

}

- adbNextEnd = 0;

- /* printf_intr("idle "); */

adbInputBuffer[0] = 1;

adbInputBuffer[1] = ADB_SR(); /* get first byte */

- /* printf_intr("0x%02x ", adbInputBuffer[1]); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("idle 0x%02x ", adbInputBuffer[1]);

+#endif

ADB_SET_SR_INPUT(); /* make sure SR is set to IN */

adbActionState = ADB_ACTION_IN; /* set next state */

ADB_SET_STATE_EVEN(); /* set bus state to even */

@@ -627,128 +779,113 @@ adb_intr_II(void)

case ADB_ACTION_IN:

adbInputBuffer[++adbInputBuffer[0]] = ADB_SR(); /* get byte */

- /* printf_intr("in 0x%02x ",

- * adbInputBuffer[adbInputBuffer[0]]); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("in 0x%02x ",

+ adbInputBuffer[adbInputBuffer[0]]);

+#endif

ADB_SET_SR_INPUT(); /* make sure SR is set to IN */

- /*

- * Check for an unsolicited Service Request (SRQ).

- * An empty SRQ packet NEVER ends, so we must manually

- * check for the following condition.

- */

- if (adbInputBuffer[0] == 4 && adbInputBuffer[2] == 0xff &&

- adbInputBuffer[3] == 0xff && adbInputBuffer[4] == 0xff &&

- intr_on && !adbNextEnd)

- do_srq = 1;

- if (adbNextEnd == 1) { /* process last byte of packet */

- adbNextEnd = 0;

- /* printf_intr("done: "); */

- /* If the following conditions are true (4 byte

- * message, last 3 bytes are 0xff) then we basically

- * got a "no response" from the ADB chip, so change

- * the message to an empty one. We also clear intr_on

- * to stop the SRQ send later on because these packets

- * normally have the SRQ bit set even when there is

- * NOT a pending SRQ. */

- if (adbInputBuffer[0] == 4 && adbInputBuffer[2] == 0xff &&

- adbInputBuffer[3] == 0xff && adbInputBuffer[4] == 0xff) {

- /* printf_intr("NO RESP "); */

- intr_on = 0;

- adbInputBuffer[0] = 0;

+ if (intr_on) { /* process last byte of packet */

+ adbInputBuffer[0]--; /* minus one */

+ /*

+ * If intr_on was true, and it's the second byte, then

+ * the byte we just discarded is really valid, so

+ * adjust the count

+ */

+ if (adbInputBuffer[0] == 2) {

+ adbInputBuffer[0]++;

}

- adbLastDevice = (adbInputBuffer[1] & 0xf0) >> 4;

- if ((!adbWaiting || adbPolling)

- && (adbInputBuffer[0] != 0)) {

- /* unsolicided - ignore if starting */

- if (!adbStarting)

- adb_handle_unsol(adbInputBuffer);

- } else

- if (!adbPolling) { /* someone asked for it */

- /* printf_intr("SOL: "); */

- /* print_single(adbInputBuffer); */

- if (adbBuffer != (long) 0) { /* if valid return data

- * pointer */

- /* get return length minus

- * extras */

- len = adbInputBuffer[0] - 1;

- /* if adb_op is ever made to

- * be called from a user

- * routine, we should use a

- * copyout or copyin here to

- * be sure we're in the

- * correct context. */

- for (i = 1; i <= len; i++)

- adbBuffer[i] = adbInputBuffer[i + 1];

- if (len < 0)

- len = 0;

- adbBuffer[0] = len;

- }

- adb_comp_exec();

- }

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80) {

+ printf_intr("done: ");

+ print_single(adbInputBuffer);

+ }

+#endif

+ adbLastDevice = ADB_CMDADDR(adbInputBuffer[1]);

+ if (adbInputBuffer[0] == 1 && !adbWaiting) { /* SRQ!!!*/

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr(" xSRQ! ");

+#endif

+ adb_guess_next_device();

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("try 0x%0x ",

+ adbLastDevice);

+#endif

+ adbOutputBuffer[0] = 1;

+ adbOutputBuffer[1] = ADBTALK(adbLastDevice, 0);

+ adbSentChars = 0; /* nothing sent yet */

+ adbActionState = ADB_ACTION_POLLING; /* set next state */

+ ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

+ ADB_SR() = adbOutputBuffer[1]; /* load byte for output */

+ adbBusState = ADB_BUS_CMD; /* set bus to cmd state */

+ ADB_SET_STATE_CMD(); /* tell ADB that we want to */

+ break;

+ }

+ /* set up data for adb_pass_up */

+ memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);

+ if (!adbWaiting && (adbInputBuffer[0] != 0)) {

+ packet.unsol = 1;

+ packet.ack_only = 0;

+ adb_pass_up(&packet);

+ } else {

+ packet.saveBuf = adbBuffer;

+ packet.compRout = adbCompRout;

+ packet.compData = adbCompData;

+ packet.unsol = 0;

+ packet.ack_only = 0;

+ adb_pass_up(&packet);

+ }

adbWaiting = 0;

- adbPolling = 0;

adbInputBuffer[0] = 0;

- adbBuffer = (long) 0;

- adbCompRout = (long) 0;

- adbCompData = (long) 0;

+ adbBuffer = (long)0;

+ adbCompRout = (long)0;

+ adbCompData = (long)0;

* Since we are done, check whether there is any data

* waiting to do out. If so, start the sending the data.

if (adbOutQueueHasData == 1) {

- /* printf_intr("XXX: DOING OUT QUEUE\n"); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("XXX: DOING OUT QUEUE\n");

+#endif

/* copy over data */

- for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++)

- adbOutputBuffer[i] = adbOutQueue.outBuf[i];

+ memcpy(adbOutputBuffer, adbOutQueue.outBuf,

+ adbOutQueue.outBuf[0] + 2);

adbBuffer = adbOutQueue.saveBuf; /* user data area */

adbCompRout = adbOutQueue.compRout; /* completion routine */

adbCompData = adbOutQueue.data; /* comp. rout. data */

adbOutQueueHasData = 0; /* currently processing

* "queue" entry */

- adbPolling = 0;

send = 1;

- /* if intr_on is true, then it's a SRQ so poll

- * other devices. */

- } else

- if (intr_on) {

- /* printf_intr("starting POLL "); */

- do_srq = 1;

- adbPolling = 1;

- } else

- if ((adbInputBuffer[1] & 0x0f) != 0x0c) {

- /* printf_intr("xC HACK "); */

- adbPolling = 1;

- send = 1;

- adbOutputBuffer[0] = 1;

- adbOutputBuffer[1] = (adbInputBuffer[1] & 0xf0) | 0x0c;

- } else {

- /* printf_intr("ending "); */

- adbBusState = ADB_BUS_IDLE;

- adbActionState = ADB_ACTION_IDLE;

- ADB_SET_STATE_IDLE_II();

- break;

- }

- /*

- * If do_srq is true then something above determined that

- * the message has ended and some device is sending a

- * service request. So we need to determine the next device

- * and send a poll to it. (If the device we send to isn't the

- * one that sent the SRQ, that ok as it will be caught

- * the next time though.)

- */

- if (do_srq) {

- /* printf_intr("SRQ! "); */

- adbPolling = 1;

- adb_guess_next_device();

- adbOutputBuffer[0] = 1;

- adbOutputBuffer[1] = ((adbLastDevice & 0x0f) << 4) | 0x0c;

- send = 1;

+ } else {

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("XXending ");

+#endif

+ adb_guess_next_device();

+ adbOutputBuffer[0] = 1;

+ adbOutputBuffer[1] = ((adbLastDevice & 0x0f) << 4) | 0x0c;

+ adbSentChars = 0; /* nothing sent yet */

+ adbActionState = ADB_ACTION_POLLING; /* set next state */

+ ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

+ ADB_SR() = adbOutputBuffer[1]; /* load byte for output */

+ adbBusState = ADB_BUS_CMD; /* set bus to cmd state */

+ ADB_SET_STATE_CMD(); /* tell ADB that we want to */

+ break;

+ }

}

* If send is true then something above determined that

* the message has ended and we need to start sending out

@@ -756,7 +893,6 @@ adb_intr_II(void)

* is data waiting to go out or because an SRQ was seen.

if (send) {

- adbNextEnd = 0;

adbSentChars = 0; /* nothing sent yet */

adbActionState = ADB_ACTION_OUT; /* set next state */

ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

@@ -767,9 +903,6 @@ adb_intr_II(void)

break;

}

/* We only get this far if the message hasn't ended yet. */

- if (!intr_on) /* if adb intr. on then the */

- adbNextEnd = 1; /* NEXT byte is the last */

switch (adbBusState) { /* set to next state */

case ADB_BUS_EVEN:

ADB_SET_STATE_ODD(); /* set state to odd */

@@ -787,9 +920,6 @@ adb_intr_II(void)

break;

case ADB_ACTION_OUT:

- adbNextEnd = 0;

- if (!adbPolling)

- adbWaiting = 1; /* not unsolicited */

i = ADB_SR(); /* clear interrupt */

adbSentChars++;

@@ -803,44 +933,74 @@ adb_intr_II(void)

ADB_SET_SR_INPUT();

adbBusState = ADB_BUS_EVEN;

ADB_SET_STATE_EVEN();

- /* printf_intr("talk out 0x%02x ", i); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("talk out 0x%02x ", i);

+#endif

+ /* we want something back */

+ adbWaiting = 1;

break;

}

- /* If it's not a TALK, check whether all data has been sent.

+ /*

+ * If it's not a TALK, check whether all data has been sent.

* If so, call the completion routine and clean up. If not,

- * advance to the next state. */

- /* printf_intr("non-talk out 0x%0x ", i); */

+ * advance to the next state.

+ */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("non-talk out 0x%0x ", i);

+#endif

ADB_SET_SR_OUTPUT();

if (adbOutputBuffer[0] == adbSentChars) { /* check for done */

- /* printf_intr("done \n"); */

- adb_comp_exec();

- adbBuffer = (long) 0;

- adbCompRout = (long) 0;

- adbCompData = (long) 0;

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("done \n");

+#endif

+ /* set up stuff for adb_pass_up */

+ memcpy(packet.data, adbOutputBuffer, adbOutputBuffer[0] + 1);

+ packet.saveBuf = adbBuffer;

+ packet.compRout = adbCompRout;

+ packet.compData = adbCompData;

+ packet.cmd = adbWaitingCmd;

+ packet.unsol = 0;

+ packet.ack_only = 1;

+ adb_pass_up(&packet);

+ /* reset "waiting" vars, just in case */

+ adbBuffer = (long)0;

+ adbCompRout = (long)0;

+ adbCompData = (long)0;

if (adbOutQueueHasData == 1) {

/* copy over data */

- for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++)

- adbOutputBuffer[i] = adbOutQueue.outBuf[i];

+ memcpy(adbOutputBuffer, adbOutQueue.outBuf,

+ adbOutQueue.outBuf[0] + 2);

adbBuffer = adbOutQueue.saveBuf; /* user data area */

adbCompRout = adbOutQueue.compRout; /* completion routine */

adbCompData = adbOutQueue.data; /* comp. rout. data */

adbOutQueueHasData = 0; /* currently processing

* "queue" entry */

- adbPolling = 0;

+ adbSentChars = 0; /* nothing sent yet */

+ adbActionState = ADB_ACTION_OUT; /* set next state */

+ ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

+ ADB_SR() = adbOutputBuffer[1]; /* load byte for output */

+ adbBusState = ADB_BUS_CMD; /* set bus to cmd state */

+ ADB_SET_STATE_CMD(); /* tell ADB that we want to

+ * send */

+ break;

} else {

+ /* send talk to last device instead */

adbOutputBuffer[0] = 1;

- adbOutputBuffer[1] = (adbOutputBuffer[1] & 0xf0) | 0x0c;

- adbPolling = 1; /* non-user poll */

+ adbOutputBuffer[1] =

+ ADBTALK(ADB_CMDADDR(adbOutputBuffer[1]), 0);

+ adbSentChars = 0; /* nothing sent yet */

+ adbActionState = ADB_ACTION_IDLE; /* set next state */

+ ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

+ ADB_SR() = adbOutputBuffer[1]; /* load byte for output */

+ adbBusState = ADB_BUS_CMD; /* set bus to cmd state */

+ ADB_SET_STATE_CMD(); /* tell ADB that we want to */

+ break;

}

- adbNextEnd = 0;

- adbSentChars = 0; /* nothing sent yet */

- adbActionState = ADB_ACTION_OUT; /* set next state */

- ADB_SET_SR_OUTPUT(); /* set shift register for OUT */

- ADB_SR() = adbOutputBuffer[1]; /* load byte for output */

- adbBusState = ADB_BUS_CMD; /* set bus to cmd state */

- ADB_SET_STATE_CMD(); /* tell ADB that we want to

- * send */

- break;

}

ADB_SR() = adbOutputBuffer[adbSentChars + 1];

switch (adbBusState) { /* advance to next state */

@@ -856,20 +1016,29 @@ adb_intr_II(void)

break;

default:

- printf_intr("strange state!!! (0x%x)\n", adbBusState);

+#ifdef ADB_DEBUG

+ if (adb_debug) {

+ printf_intr("strange state!!! (0x%x)\n",

+ adbBusState);

+ }

+#endif

break;

}

break;

default:

- printf_intr("adb: unknown ADB state (during intr)\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: unknown ADB state (during intr)\n");

+#endif

+ break;

}

ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */

splx(s); /* restore */

- return;

+ return (1);

}

@@ -878,22 +1047,22 @@ adb_intr_II(void)

* send_adb version for II series machines

int

-send_adb_II(u_char * in, u_char * buffer, void *compRout, void *data, int command)

+send_adb_II(u_char *in, u_char *buffer, void *compRout, void *data, int command)

{

- int i, s, len;

+ int s, len;

if (adbActionState == ADB_ACTION_NOTREADY) /* return if ADB not

* available */

return 1;

- s = splhigh(); /* don't interrupt while we are messing with

- * the ADB */

+ /* Don't interrupt while we are messing with the ADB */

+ s = splhigh();

if (0 != adbOutQueueHasData) { /* right now, "has data" means "full" */

splx(s); /* sorry, try again later */

return 1;

}

- if ((long) in == (long) 0) { /* need to convert? */

+ if ((long)in == (long)0) { /* need to convert? */

* Don't need to use adb_cmd_extra here because this section

* will be called ONLY when it is an ADB command (no RTC or

@@ -906,15 +1075,13 @@ send_adb_II(u_char * in, u_char * buffer, void *compRout, void *data, int comman

len = 0;/* no additional data */

adbOutQueue.outBuf[0] = 1 + len; /* command + addl. data */

- adbOutQueue.outBuf[1] = (u_char) command; /* load command */

+ adbOutQueue.outBuf[1] = (u_char)command; /* load command */

- for (i = 1; i <= len; i++) /* copy additional output

- * data, if any */

- adbOutQueue.outBuf[1 + i] = buffer[i];

+ /* copy additional output data, if any */

+ memcpy(adbOutQueue.outBuf + 2, buffer + 1, len);

} else

/* if data ready, just copy over */

- for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++)

- adbOutQueue.outBuf[i] = in[i];

+ memcpy(adbOutQueue.outBuf, in, in[0] + 2);

adbOutQueue.saveBuf = buffer; /* save buffer to know where to save

* result */

@@ -923,11 +1090,10 @@ send_adb_II(u_char * in, u_char * buffer, void *compRout, void *data, int comman

adbOutQueue.data = data;/* save completion routine data pointer */

if ((adbActionState == ADB_ACTION_IDLE) && /* is ADB available? */

- (ADB_INTR_IS_OFF) &&/* and no incoming interrupts? */

- (adbPolling == 0)) {/* and we are not currently polling */

+ (ADB_INTR_IS_OFF)) { /* and no incoming interrupts? */

/* then start command now */

- for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++) /* copy over data */

- adbOutputBuffer[i] = adbOutQueue.outBuf[i];

+ memcpy(adbOutputBuffer, adbOutQueue.outBuf,

+ adbOutQueue.outBuf[0] + 2); /* copy over data */

adbBuffer = adbOutQueue.saveBuf; /* pointer to user data

* area */

@@ -950,12 +1116,15 @@ send_adb_II(u_char * in, u_char * buffer, void *compRout, void *data, int comman

splx(s);

- if (0x0100 <= (s & 0x0700)) /* were VIA1 interrupts blocked ? */

+ if (0x0100 <= (s & 0x0700)) /* were VIA1 interrupts blocked? */

/* poll until message done */

while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)

- || (adbWaiting == 1) || (adbPolling == 1))

- if (ADB_SR_INTR_IS_ON) /* wait for "interrupt" */

- adb_intr_II(); /* go process "interrupt" */

+ || (adbWaiting == 1))

+ if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */

+ adb_intr_II(NULL); /* go process it */

+ if (adb_polling)

+ adb_soft_intr();

+ }

return 0;

}

@@ -971,8 +1140,10 @@ adb_guess_next_device(void)

int last, i, dummy;

if (adbStarting) {

- /* start polling EVERY device, since we can't be sure there is

- * anything in the device table yet */

+ /*

+ * Start polling EVERY device, since we can't be sure there is

+ * anything in the device table yet

+ */

if (adbLastDevice < 1 || adbLastDevice > 15)

adbLastDevice = 1;

if (++adbLastDevice > 15) /* point to next one */

@@ -996,7 +1167,7 @@ adb_guess_next_device(void)

* device! This can happen if

* there are no devices on the

* bus */

- dummy = 2;

+ dummy = 1;

break;

}

/* found the next device */

@@ -1007,33 +1178,37 @@ adb_guess_next_device(void)

}

return adbLastDevice;

}

* Called when when an adb interrupt happens.

* This routine simply transfers control over to the appropriate

* code for the machine we are running on.

-void

-adb_intr(void)

+int

+adb_intr(void *arg)

{

switch (adbHardware) {

- case ADB_HW_II:

- adb_intr_II();

+ case ADB_HW_II:

+ return adb_intr_II(arg);

break;

case ADB_HW_IISI:

- adb_intr_IIsi();

+ return adb_intr_IIsi(arg);

break;

- case ADB_HW_PB:

+ case ADB_HW_PB: /* Should not come through here. */

break;

case ADB_HW_CUDA:

- adb_intr_cuda();

+ return adb_intr_cuda(arg);

break;

case ADB_HW_UNKNOWN:

break;

}

+ return (-1);

}

@@ -1043,10 +1218,11 @@ adb_intr(void)

* IIsi version of adb_intr

-void

-adb_intr_IIsi(void)

+int

+adb_intr_IIsi(void *arg)

{

- int i, ending, len;

+ struct adbCommand packet;

+ int i, ending;

unsigned int s;

s = splhigh(); /* can't be too careful - might be called */

@@ -1071,7 +1247,7 @@ switch_start:

ADB_SET_STATE_ACKON(); /* start ACK to ADB chip */

delay(ADB_DELAY); /* delay */

ADB_SET_STATE_ACKOFF(); /* end ACK to ADB chip */

- (void)intr_dispatch(0x70);

+ (void)intr_dispatch(0x70); /* grab any serial interrupts */

break;

case ADB_ACTION_IN:

@@ -1085,15 +1261,19 @@ switch_start:

ADB_SET_STATE_ACKON(); /* start ACK to ADB chip */

delay(ADB_DELAY); /* delay */

ADB_SET_STATE_ACKOFF(); /* end ACK to ADB chip */

- (void)intr_dispatch(0x70);

+ (void)intr_dispatch(0x70); /* grab any serial interrupts */

if (1 == ending) { /* end of message? */

ADB_SET_STATE_INACTIVE(); /* signal end of frame */

- /* this section _should_ handle all ADB and RTC/PRAM

- * type commands, */

- /* but there may be more... */

- /* note: commands are always at [4], even for rtc/pram

- * commands */

+ /*

+ * This section _should_ handle all ADB and RTC/PRAM

+ * type commands, but there may be more... Note:

+ * commands are always at [4], even for rtc/pram

+ * commands

+ */

+ /* set up data for adb_pass_up */

+ memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);

if ((adbWaiting == 1) && /* are we waiting AND */

(adbInputBuffer[4] == adbWaitingCmd) && /* the cmd we sent AND */

((adbInputBuffer[2] == 0x00) || /* it's from the ADB

@@ -1101,40 +1281,22 @@ switch_start:

(adbInputBuffer[2] == 0x01))) { /* it's from the

* PRAM/RTC device */

- /* is this data we are waiting for? */

- if (adbBuffer != (long) 0) { /* if valid return data

- * pointer */

- /* get return length minus extras */

- len = adbInputBuffer[0] - 4;

- /* if adb_op is ever made to be called

- * from a user routine, we should use

- * a copyout or copyin here to be sure

- * we're in the correct context */

- for (i = 1; i <= len; i++)

- adbBuffer[i] = adbInputBuffer[4 + i];

- if (len < 0)

- len = 0;

- adbBuffer[0] = len;

- }

- adb_comp_exec(); /* call completion

- * routine */

+ packet.saveBuf = adbBuffer;

+ packet.compRout = adbCompRout;

+ packet.compData = adbCompData;

+ packet.unsol = 0;

+ packet.ack_only = 0;

+ adb_pass_up(&packet);

adbWaitingCmd = 0; /* reset "waiting" vars */

adbWaiting = 0;

- adbBuffer = (long) 0;

- adbCompRout = (long) 0;

- adbCompData = (long) 0;

+ adbBuffer = (long)0;

+ adbCompRout = (long)0;

+ adbCompData = (long)0;

} else {

- /* pass the data off to the handler */

- /* This section IGNORES all data that is not

- * from the ADB sub-device. That is, not from

- * rtc or pram. Maybe we should fix later,

- * but do the other devices every send things

- * without being asked? */

- if (adbStarting == 0) /* ignore if during

- * adbreinit */

- if (adbInputBuffer[2] == 0x00)

- adb_handle_unsol(adbInputBuffer);

+ packet.unsol = 1;

+ packet.ack_only = 0;

+ adb_pass_up(&packet);

}

adbActionState = ADB_ACTION_IDLE;

@@ -1146,7 +1308,7 @@ switch_start:

adbActionState = ADB_ACTION_OUT; /* set next state */

delay(ADB_DELAY); /* delay */

- (void)intr_dispatch(0x70);

+ (void)intr_dispatch(0x70); /* grab any serial interrupts */

if (ADB_INTR_IS_ON) { /* ADB intr low during

* write */

@@ -1187,13 +1349,13 @@ switch_start:

adbWriteDelay = 1; /* must retry when done with

* read */

delay(ADB_DELAY); /* delay */

- (void)intr_dispatch(0x70);

+ (void)intr_dispatch(0x70); /* grab any serial interrupts */

goto switch_start; /* process next state right

* now */

break;

}

delay(ADB_DELAY); /* required delay */

- (void)intr_dispatch(0x70);

+ (void)intr_dispatch(0x70); /* grab any serial interrupts */

if (adbOutputBuffer[0] == adbSentChars) { /* check for done */

if (0 == adb_cmd_result(adbOutputBuffer)) { /* do we expect data

@@ -1201,13 +1363,22 @@ switch_start:

adbWaiting = 1; /* signal waiting for return */

adbWaitingCmd = adbOutputBuffer[2]; /* save waiting command */

} else {/* no talk, so done */

- adb_comp_exec(); /* call completion

- * routine */

- adbWaitingCmd = 0; /* reset "waiting" vars,

- * just in case */

- adbBuffer = (long) 0;

- adbCompRout = (long) 0;

- adbCompData = (long) 0;

+ /* set up stuff for adb_pass_up */

+ memcpy(packet.data, adbInputBuffer,

+ adbInputBuffer[0] + 1);

+ packet.saveBuf = adbBuffer;

+ packet.compRout = adbCompRout;

+ packet.compData = adbCompData;

+ packet.cmd = adbWaitingCmd;

+ packet.unsol = 0;

+ packet.ack_only = 1;

+ adb_pass_up(&packet);

+ /* reset "waiting" vars, just in case */

+ adbWaitingCmd = 0;

+ adbBuffer = (long)0;

+ adbCompRout = (long)0;

+ adbCompData = (long)0;

}

adbWriteDelay = 0; /* done writing */

@@ -1221,18 +1392,25 @@ switch_start:

break;

case ADB_ACTION_NOTREADY:

- printf_intr("adb: not yet initialized\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: not yet initialized\n");

+#endif

break;

default:

- printf_intr("intr: unknown ADB state\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("intr: unknown ADB state\n");

+#endif

+ break;

}

ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */

splx(s); /* restore */

- return;

+ return (1);

} /* end adb_intr_IIsi */

@@ -1240,27 +1418,27 @@ switch_start:

* if the device is currently busy, and there is no data waiting to go out, then

* the data is "queued" in the outgoing buffer. If we are already waiting, then

* we return.

- * in: if (in==0) then the command string is built from command and buffer

- * if (in!=0) then in is used as the command string

- * buffer: additional data to be sent (used only if in==0)

+ * in: if (in == 0) then the command string is built from command and buffer

+ * if (in != 0) then in is used as the command string

+ * buffer: additional data to be sent (used only if in == 0)

* this is also where return data is stored

* compRout: the completion routine that is called when then return value

* is received (if a return value is expected)

* data: a data pointer that can be used by the completion routine

- * command: an ADB command to be sent (used only if in==0)

+ * command: an ADB command to be sent (used only if in == 0)

int

-send_adb_IIsi(u_char * in, u_char * buffer, void *compRout, void *data, int

+send_adb_IIsi(u_char *in, u_char *buffer, void *compRout, void *data, int

command)

{

- int i, s, len;

+ int s, len;

if (adbActionState == ADB_ACTION_NOTREADY)

return 1;

- s = splhigh(); /* don't interrupt while we are messing with

- * the ADB */

+ /* Don't interrupt while we are messing with the ADB */

+ s = splhigh();

if ((adbActionState == ADB_ACTION_IDLE) && /* ADB available? */

(ADB_INTR_IS_OFF)) {/* and no incoming interrupt? */

@@ -1274,10 +1452,12 @@ send_adb_IIsi(u_char * in, u_char * buffer, void *compRout, void *data, int

return 1; /* really busy! */

}

- if ((long) in == (long) 0) { /* need to convert? */

- /* don't need to use adb_cmd_extra here because this section

- * will be called */

- /* ONLY when it is an ADB command (no RTC or PRAM) */

+ if ((long)in == (long)0) { /* need to convert? */

+ /*

+ * Don't need to use adb_cmd_extra here because this section

+ * will be called ONLY when it is an ADB command (no RTC or

+ * PRAM)

+ */

if ((command & 0x0c) == 0x08) /* copy addl data ONLY if

* doing a listen! */

len = buffer[0]; /* length of additional data */

@@ -1287,14 +1467,13 @@ send_adb_IIsi(u_char * in, u_char * buffer, void *compRout, void *data, int

adbOutputBuffer[0] = 2 + len; /* dev. type + command + addl.

* data */

adbOutputBuffer[1] = 0x00; /* mark as an ADB command */

- adbOutputBuffer[2] = (u_char) command; /* load command */

+ adbOutputBuffer[2] = (u_char)command; /* load command */

- for (i = 1; i <= len; i++) /* copy additional output

- * data, if any */

- adbOutputBuffer[2 + i] = buffer[i];

+ /* copy additional output data, if any */

+ memcpy(adbOutputBuffer + 3, buffer + 1, len);

} else

- for (i = 0; i <= (adbOutputBuffer[0] + 1); i++)

- adbOutputBuffer[i] = in[i];

+ /* if data ready, just copy over */

+ memcpy(adbOutputBuffer, in, in[0] + 2);

adbSentChars = 0; /* nothing sent yet */

adbBuffer = buffer; /* save buffer to know where to save result */

@@ -1318,153 +1497,259 @@ send_adb_IIsi(u_char * in, u_char * buffer, void *compRout, void *data, int

splx(s);

- if (0x0100 <= (s & 0x0700)) /* were VIA1 interrupts blocked ? */

+ if (0x0100 <= (s & 0x0700)) /* were VIA1 interrupts blocked? */

/* poll until byte done */

while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)

|| (adbWaiting == 1))

- if (ADB_SR_INTR_IS_ON) /* wait for "interrupt" */

- adb_intr_IIsi(); /* go process

- * "interrupt" */

+ if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */

+ adb_intr_IIsi(NULL); /* go process it */

+ if (adb_polling)

+ adb_soft_intr();

+ }

- return 0;

+ return 0;

} /* send_adb_IIsi */

-/*

- * adb_comp_exec

- * This is a general routine that calls the completion routine if there is one.

+/*

+ * adb_pass_up is called by the interrupt-time routines.

+ * It takes the raw packet data that was received from the

+ * device and puts it into the queue that the upper half

+ * processes. It then signals for a soft ADB interrupt which

+ * will eventually call the upper half routine (adb_soft_intr).

+ *

+ * If in->unsol is 0, then this is either the notification

+ * that the packet was sent (on a LISTEN, for example), or the

+ * response from the device (on a TALK). The completion routine

+ * is called only if the user specified one.

+ *

+ * If in->unsol is 1, then this packet was unsolicited and

+ * so we look up the device in the ADB device table to determine

+ * what it's default service routine is.

+ *

+ * If in->ack_only is 1, then we really only need to call

+ * the completion routine, so don't do any other stuff.

+ *

+ * Note that in->data contains the packet header AND data,

+ * while adbInbound[]->data contains ONLY data.

+ *

+ * Note: Called only at interrupt time. Assumes this.

void

-adb_comp_exec(void)

+adb_pass_up(struct adbCommand *in)

{

- if ((long) 0 != adbCompRout) /* don't call if empty return location */

-#if defined(__NetBSD__) || defined(__OpenBSD__)

- asm("

- movml #0xffff, sp@- | save all registers

- movl %0, a2 | adbCompData

- movl %1, a1 | adbCompRout

- movl %2, a0 | adbBuffer

- movl %3, d0 | adbWaitingCmd

- jbsr a1@ | go call the routine

- movml sp@+, #0xffff | restore all registers"

- :

- :"g"(adbCompData), "g"(adbCompRout),

- "g"(adbBuffer), "g"(adbWaitingCmd)

- :"d0", "a0", "a1", "a2");

-#else /* for macos based testing */

- asm {

- movem.l a0/a1/a2/d0, -(a7)

- move.l adbCompData, a2

- move.l adbCompRout, a1

- move.l adbBuffer, a0

- move.w adbWaitingCmd, d0

- jsr(a1)

- movem.l(a7) +, d0/a2/a1/a0

+ int start = 0, len = 0, cmd = 0;

+ ADBDataBlock block;

+ /* temp for testing */

+ /*u_char *buffer = 0;*/

+ /*u_char *compdata = 0;*/

+ /*u_char *comprout = 0;*/

+ if (adbInCount >= ADB_QUEUE) {

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: ring buffer overflow\n");

+#endif

+ return;

+ }

+ if (in->ack_only) {

+ len = in->data[0];

+ cmd = in->cmd;

+ start = 0;

+ } else {

+ switch (adbHardware) {

+ case ADB_HW_II:

+ cmd = in->data[1];

+ if (in->data[0] < 2)

+ len = 0;

+ else

+ len = in->data[0]-1;

+ start = 1;

+ break;

+ case ADB_HW_IISI:

+ case ADB_HW_CUDA:

+ /* If it's unsolicited, accept only ADB data for now */

+ if (in->unsol)

+ if (0 != in->data[2])

+ return;

+ cmd = in->data[4];

+ if (in->data[0] < 5)

+ len = 0;

+ else

+ len = in->data[0]-4;

+ start = 4;

+ break;

+ case ADB_HW_PB:

+ cmd = in->data[1];

+ if (in->data[0] < 2)

+ len = 0;

+ else

+ len = in->data[0]-1;

+ start = 1;

+ break;

+ case ADB_HW_UNKNOWN:

+ return;

}

+ /* Make sure there is a valid device entry for this device */

+ if (in->unsol) {

+ /* ignore unsolicited data during adbreinit */

+ if (adbStarting)

+ return;

+ /* get device's comp. routine and data area */

+ if (-1 == get_adb_info(&block, ADB_CMDADDR(cmd)))

+ return;

+ }

+ /*

+ * If this is an unsolicited packet, we need to fill in

+ * some info so adb_soft_intr can process this packet

+ * properly. If it's not unsolicited, then use what

+ * the caller sent us.

+ */

+ if (in->unsol) {

+ adbInbound[adbInTail].compRout = (void *)block.dbServiceRtPtr;

+ adbInbound[adbInTail].compData = (void *)block.dbDataAreaAddr;

+ adbInbound[adbInTail].saveBuf = (void *)adbInbound[adbInTail].data;

+ } else {

+ adbInbound[adbInTail].compRout = (void *)in->compRout;

+ adbInbound[adbInTail].compData = (void *)in->compData;

+ adbInbound[adbInTail].saveBuf = (void *)in->saveBuf;

+ }

+#ifdef ADB_DEBUG

+ if (adb_debug && in->data[1] == 2)

+ printf_intr("adb: caught error\n");

#endif

+ /* copy the packet data over */

+ /*

+ * TO DO: If the *_intr routines fed their incoming data

+ * directly into an adbCommand struct, which is passed to

+ * this routine, then we could eliminate this copy.

+ */

+ memcpy(adbInbound[adbInTail].data + 1, in->data + start + 1, len);

+ adbInbound[adbInTail].data[0] = len;

+ adbInbound[adbInTail].cmd = cmd;

+ adbInCount++;

+ if (++adbInTail >= ADB_QUEUE)

+ adbInTail = 0;

+ /*

+ * If the debugger is running, call upper half manually.

+ * Otherwise, trigger a soft interrupt to handle the rest later.

+ */

+ if (adb_polling)

+ adb_soft_intr();

+ else

+ setsoftadb();

+ return;

}

- * This routine handles what needs to be done after an unsolicited

- * message is read from the ADB device. 'in' points to the raw

- * data received from the device, including device number

- * (on IIsi) and result code.

+ * Called to process the packets after they have been

+ * placed in the incoming queue.

- * Note that the service (completion) routine for an unsolicited

- * message is whatever is set in the ADB device table. This is

- * different than for a device responding to a specific request,

- * where the completion routine is defined by the caller.

void

-adb_handle_unsol(u_char * in)

+adb_soft_intr(void)

{

- int i, cmd = 0;

- u_char data[MAX_ADB_MSG_LENGTH];

+ int s;

+ int cmd = 0;

u_char *buffer = 0;

- ADBDataBlock block;

+ u_char *comprout = 0;

+ u_char *compdata = 0;

- /* make local copy so we don't destroy the real one - it may be needed

- * later. */

- for (i = 0; i <= (in[0] + 1); i++)

- data[i] = in[i];

- switch (adbHardware) {

- case ADB_HW_II:

- /* adjust the "length" byte */

- cmd = data[1];

- if (data[0] < 2)

- data[1] = 0;

- else

- data[1] = data[0] - 1;

- buffer = (data + 1);

- break;

- case ADB_HW_IISI:

- case ADB_HW_CUDA:

- /* only handles ADB for now */

- if (0 != *(data + 2))

- return;

- /* adjust the "length" byte */

- cmd = data[4];

- if (data[0] < 5)

- data[4] = 0;

- else

- data[4] = data[0] - 4;

- buffer = (data + 4);

- break;

- case ADB_HW_PB:

- return; /* how does PM handle "unsolicited" messages? */

+#if 0

+ s = splhigh();

+ printf_intr("sr: %x\n", (s & 0x0700));

+ splx(s);

+#endif

- case ADB_HW_UNKNOWN:

- return;

- }

+/*delay(2*ADB_DELAY);*/

- if (-1 == get_adb_info(&block, ((cmd & 0xf0) >> 4)))

- return;

+ while (adbInCount) {

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("%x %x %x ",

+ adbInCount, adbInHead, adbInTail);

+#endif

+ /* get the data we need from the queue */

+ buffer = adbInbound[adbInHead].saveBuf;

+ comprout = adbInbound[adbInHead].compRout;

+ compdata = adbInbound[adbInHead].compData;

+ cmd = adbInbound[adbInHead].cmd;

+ /* copy over data to data area if it's valid */

+ /*

+ * Note that for unsol packets we don't want to copy the

+ * data anywhere, so buffer was already set to 0.

+ * For ack_only buffer was set to 0, so don't copy.

+ */

+ if (buffer)

+ memcpy(buffer, adbInbound[adbInHead].data,

+ adbInbound[adbInHead].data[0] + 1);

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80) {

+ printf_intr("%p %p %p %x ",

+ buffer, comprout, compdata, (short)cmd);

+ printf_intr("buf: ");

+ print_single(adbInbound[adbInHead].data);

+ }

+#endif

- /* call default completion routine if it's valid */

- /* TO DO: This section of code is somewhat redundant with

- * adb_comp_exec (above). Some day we may want to generalize it and

- * make it a single function. */

- if ((long) 0 != (long) block.dbServiceRtPtr) {

+ /* call default completion routine if it's valid */

+ if (comprout) {

#if defined(__NetBSD__) || defined(__OpenBSD__)

- asm("

- movml #0xffff, sp@- | save all registers

- movl %0, a2 | block.dbDataAreaAddr

- movl %1, a1 | block.dbServiceRtPtr

- movl %2, a0 | buffer

- movl %3, d0 | cmd

- jbsr a1@ | go call the routine

- movml sp@+, #0xffff | restore all registers"

- :

- : "g"(block.dbDataAreaAddr),

- "g"(block.dbServiceRtPtr), "g"(buffer), "g"(cmd)

- : "d0", "a0", "a1", "a2");

+ __asm __volatile (

+ " movml #0xffff,sp@- \n" /* save all regs */

+ " movl %0,a2 \n" /* compdata */

+ " movl %1,a1 \n" /* comprout */

+ " movl %2,a0 \n" /* buffer */

+ " movl %3,d0 \n" /* cmd */

+ " jbsr a1@ \n" /* go call routine */

+ " movml sp@+,#0xffff" /* restore all regs */

+ :

+ : "g"(compdata), "g"(comprout),

+ "g"(buffer), "g"(cmd)

+ : "d0", "a0", "a1", "a2");

#else /* for macos based testing */

- asm

- {

- movem.l a0/a1/a2/d0, -(a7)

- move.l block.dbDataAreaAddr, a2

- move.l block.dbServiceRtPtr, a1

- move.l buffer, a0

- move.w cmd, d0

- jsr(a1)

- movem.l(a7) +, d0/a2/a1/a0

- }

+ asm

+ {

+ movem.l a0/a1/a2/d0, -(a7)

+ move.l compdata, a2

+ move.l comprout, a1

+ move.l buffer, a0

+ move.w cmd, d0

+ jsr(a1)

+ movem.l(a7)+, d0/a2/a1/a0

+ }

#endif

+ }

+ s = splhigh();

+ adbInCount--;

+ if (++adbInHead >= ADB_QUEUE)

+ adbInHead = 0;

+ splx(s);

}

return;

}

- * This is my version of the ADBOp routine. It mainly just calls the hardware-specific

- * routine.

+ * This is my version of the ADBOp routine. It mainly just calls the

+ * hardware-specific routine.

* data : pointer to data area to be used by compRout

* compRout : completion routine

@@ -1472,8 +1757,8 @@ adb_handle_unsol(u_char * in)

* byte 0 = # of bytes

* : for TALK: points to place to save return data

* command : the adb command to send

- * result : 0 = success

- * : -1 = could not complete

+ * result : 0 = success

+ * : -1 = could not complete

int

adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)

@@ -1482,9 +1767,8 @@ adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)

switch (adbHardware) {

case ADB_HW_II:

- result = send_adb_II((u_char *) 0,

- (u_char *) buffer, (void *) compRout,

- (void *) data, (int) command);

+ result = send_adb_II((u_char *)0, (u_char *)buffer,

+ (void *)compRout, (void *)data, (int)command);

if (result == 0)

return 0;

else

@@ -1492,9 +1776,8 @@ adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)

break;

case ADB_HW_IISI:

- result = send_adb_IIsi((u_char *) 0,

- (u_char *) buffer, (void *) compRout,

- (void *) data, (int) command);

+ result = send_adb_IIsi((u_char *)0, (u_char *)buffer,

+ (void *)compRout, (void *)data, (int)command);

* I wish I knew why this delay is needed. It usually needs to

* be here when several commands are sent in close succession,

@@ -1519,9 +1802,8 @@ adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)

break;

case ADB_HW_CUDA:

- result = send_adb_cuda((u_char *) 0,

- (u_char *) buffer, (void *) compRout,

- (void *) data, (int) command);

+ result = send_adb_cuda((u_char *)0, (u_char *)buffer,

+ (void *)compRout, (void *)data, (int)command);

if (result == 0)

return 0;

else

@@ -1536,33 +1818,92 @@ adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)

- * adb_cleanup

- * This routine simply calls the appropriate version of the adb_cleanup routine.

+ * adb_hw_setup

+ * This routine sets up the possible machine specific hardware

+ * config (mainly VIA settings) for the various models.

void

-adb_cleanup(u_char * in)

+adb_hw_setup(void)

{

volatile int i;

+ u_char send_string[ADB_MAX_MSG_LENGTH];

switch (adbHardware) {

case ADB_HW_II:

+ via1_register_irq(2, adb_intr_II, NULL, NULL);

+ via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:

+ * outputs */

+ via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */

+ via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set

+ * to IN (II, IIsi) */

+ adbActionState = ADB_ACTION_IDLE; /* used by all types of

+ * hardware (II, IIsi) */

+ adbBusState = ADB_BUS_IDLE; /* this var. used in II-series

+ * code only */

+ via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts

+ * are on (II, IIsi) */

+ ADB_SET_STATE_IDLE_II(); /* set ADB bus state to idle */

ADB_VIA_CLR_INTR(); /* clear interrupt */

break;

case ADB_HW_IISI:

+ via1_register_irq(2, adb_intr_IIsi, NULL, NULL);

+ via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:

+ * outputs */

+ via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */

+ via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set

+ * to IN (II, IIsi) */

+ adbActionState = ADB_ACTION_IDLE; /* used by all types of

+ * hardware (II, IIsi) */

+ adbBusState = ADB_BUS_IDLE; /* this var. used in II-series

+ * code only */

+ via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts

+ * are on (II, IIsi) */

+ ADB_SET_STATE_IDLE_IISI(); /* set ADB bus state to idle */

/* get those pesky clock ticks we missed while booting */

- adb_cleanup_IIsi(in);

+ for (i = 0; i < 30; i++) {

+ delay(ADB_DELAY);

+ adb_hw_setup_IIsi(send_string);

+#ifdef ADB_DEBUG

+ if (adb_debug) {

+ printf_intr("adb: cleanup: ");

+ print_single(send_string);

+ }

+#endif

+ delay(ADB_DELAY);

+ if (ADB_INTR_IS_OFF)

+ break;

+ }

break;

case ADB_HW_PB:

- * XXX - really PM_VIA_CLR_INTR - should we put it in

+ * XXX - really PM_VIA_CLR_INTR - should we put it in

* pm_direct.h?

- via_reg(VIA1, vIFR) = 0x90; /* clear interrupt */

+ pm_hw_setup();

break;

case ADB_HW_CUDA:

+ via1_register_irq(2, adb_intr_cuda, NULL, NULL);

+ via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:

+ * outputs */

+ via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */

+ via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set

+ * to IN */

+ via_reg(VIA1, vACR) = (via_reg(VIA1, vACR) | 0x0c) & ~0x10;

+ adbActionState = ADB_ACTION_IDLE; /* used by all types of

+ * hardware */

+ adbBusState = ADB_BUS_IDLE; /* this var. used in II-series

+ * code only */

+ via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts

+ * are on */

+ ADB_SET_STATE_IDLE_CUDA(); /* set ADB bus state to idle */

+ /* sort of a device reset */

i = ADB_SR(); /* clear interrupt */

ADB_VIA_INTR_DISABLE(); /* no interrupts while clearing */

ADB_SET_STATE_IDLE_CUDA(); /* reset state to idle */

@@ -1579,20 +1920,24 @@ adb_cleanup(u_char * in)

break;

case ADB_HW_UNKNOWN:

+ default:

+ via_reg(VIA1, vIER) = 0x04; /* turn interrupts off - TO

+ * DO: turn PB ints off? */

return;

+ break;

}

- * adb_cleanup_IIsi

+ * adb_hw_setup_IIsi

* This is sort of a "read" routine that forces the adb hardware through a read cycle

* if there is something waiting. This helps "clean up" any commands that may have gotten

* stuck or stopped during the boot process.

void

-adb_cleanup_IIsi(u_char * buffer)

+adb_hw_setup_IIsi(u_char *buffer)

{

int i;

int dummy;

@@ -1614,17 +1959,21 @@ adb_cleanup_IIsi(u_char * buffer)

endofframe = 0;

while (0 == endofframe) {

- /* poll for ADB interrupt and watch for timeout */

- /* if time out, keep going in hopes of not hanging the

- * ADB chip - I think */

+ /*

+ * Poll for ADB interrupt and watch for timeout.

+ * If time out, keep going in hopes of not hanging

+ * the ADB chip - I think

+ */

my_time = ADB_DELAY * 5;

while ((ADB_SR_INTR_IS_OFF) && (my_time-- > 0))

dummy = via_reg(VIA1, vBufB);

buffer[i++] = ADB_SR(); /* reset interrupt flag by

* reading vSR */

- /* perhaps put in a check here that ignores all data

- * after the first MAX_ADB_MSG_LENGTH bytes ??? */

+ /*

+ * Perhaps put in a check here that ignores all data

+ * after the first ADB_MAX_MSG_LENGTH bytes ???

+ */

if (ADB_INTR_IS_OFF) /* check for end of frame */

endofframe = 1;

@@ -1643,7 +1992,7 @@ adb_cleanup_IIsi(u_char * buffer)

splx(s); /* restore interrupts */

return;

-} /* adb_cleanup_IIsi */

+} /* adb_hw_setup_IIsi */

@@ -1654,110 +2003,49 @@ adb_cleanup_IIsi(u_char * buffer)

void

adb_reinit(void)

{

- u_char send_string[MAX_ADB_MSG_LENGTH];

- int s = 0;

+ u_char send_string[ADB_MAX_MSG_LENGTH];

+ ADBDataBlock data; /* temp. holder for getting device info */

volatile int i, x;

+ int s;

int command;

int result;

int saveptr; /* point to next free relocation address */

int device;

int nonewtimes; /* times thru loop w/o any new devices */

- ADBDataBlock data; /* temp. holder for getting device info */

+ adb_setup_hw_type(); /* setup hardware type */

/* Make sure we are not interrupted while building the table. */

- if (adbHardware != ADB_HW_PB) /* ints must be on for PB? */

+ /* ints must be on for PB & IOP (at least, for now) */

+ if (adbHardware != ADB_HW_PB)

s = splhigh();

+ else

+ s = 0; /* XXX shut the compiler up*/

ADBNumDevices = 0; /* no devices yet */

/* Let intr routines know we are running reinit */

adbStarting = 1;

- /* Initialize the ADB table. For now, we'll always use the same table

- * that is defined at the beginning of this file - no mallocs. */

- for (i = 0; i < 16; i++)

- ADBDevTable[i].devType = 0;

- adb_setup_hw_type(); /* setup hardware type */

- /* Set up all the VIA bits we need to do the ADB stuff. */

- switch (adbHardware) {

- case ADB_HW_II:

- via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:

- * outputs */

- via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */

- via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set

- * to IN (II, IIsi) */

- adbActionState = ADB_ACTION_IDLE; /* used by all types of

- * hardware (II, IIsi) */

- adbBusState = ADB_BUS_IDLE; /* this var. used in II-series

- * code only */

- via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts

- * are on (II, IIsi) */

- ADB_SET_STATE_IDLE_II(); /* set ADB bus state to idle */

- break;

- case ADB_HW_IISI:

- via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:

- * outputs */

- via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */

- via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set

- * to IN (II, IIsi) */

- adbActionState = ADB_ACTION_IDLE; /* used by all types of

- * hardware (II, IIsi) */

- adbBusState = ADB_BUS_IDLE; /* this var. used in II-series

- * code only */

- via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts

- * are on (II, IIsi) */

- ADB_SET_STATE_IDLE_IISI(); /* set ADB bus state to idle */

- break;

- case ADB_HW_PB:

- break; /* there has to be more than this? */

- case ADB_HW_CUDA:

- via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:

- * outputs */

- via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */

- via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set

- * to IN */

- via_reg(VIA1, vACR) = (via_reg(VIA1, vACR) | 0x0c) & ~0x10;

- adbActionState = ADB_ACTION_IDLE; /* used by all types of

- * hardware */

- adbBusState = ADB_BUS_IDLE; /* this var. used in II-series

- * code only */

- via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts

- * are on */

- ADB_SET_STATE_IDLE_CUDA(); /* set ADB bus state to idle */

- break;

- case ADB_HW_UNKNOWN: /* if type unknown then skip out */

- default:

- via_reg(VIA1, vIER) = 0x04; /* turn interrupts off - TO

- * DO: turn PB ints off? */

- splx(s);

- return;

- }

- * Clear out any "leftover" commands. Remember that up until this

- * point, the interrupt routine will be either off or it should be

- * able to ignore inputs until the device table is built.

+ * Initialize the ADB table. For now, we'll always use the same table

+ * that is defined at the beginning of this file - no mallocs.

- for (i = 0; i < 30; i++) {

- delay(ADB_DELAY);

- adb_cleanup(send_string);

- printf_intr("adb: cleanup: ");

- print_single(send_string);

- delay(ADB_DELAY);

- if (ADB_INTR_IS_OFF)

- break;

+ for (i = 0; i < 16; i++) {

+ ADBDevTable[i].devType = 0;

+ ADBDevTable[i].origAddr = ADBDevTable[i].currentAddr = 0;

}

+ adb_hw_setup(); /* init the VIA bits and hard reset ADB */

+ delay(1000);

/* send an ADB reset first */

- adb_op_sync((Ptr) 0, (Ptr) 0, (Ptr) 0, (short) 0x00);

+ (void)adb_op_sync((Ptr)0, (Ptr)0, (Ptr)0, (short)0x00);

+ delay(3000);

- /* Probe for ADB devices. Probe devices 1-15 quickly to determine

+ /*

+ * Probe for ADB devices. Probe devices 1-15 quickly to determine

* which device addresses are in use and which are free. For each

* address that is in use, move the device at that address to a higher

* free address. Continue doing this at that address until no device

@@ -1765,25 +2053,31 @@ adb_reinit(void)

* back to the original address. Do this for the remaining addresses

* that we determined were in use.

- * When finished, do this entire process over again with the updated list

- * of in use addresses. Do this until no new devices have been found

- * in 20 passes though the in use address list. (This probably seems

- * long and complicated, but it's the best way to detect multiple

+ * When finished, do this entire process over again with the updated

+ * list of in use addresses. Do this until no new devices have been

+ * found in 20 passes though the in use address list. (This probably

+ * seems long and complicated, but it's the best way to detect multiple

* devices at the same address - sometimes it takes a couple of tries

- * before the collision is detected.) */

+ * before the collision is detected.)

+ */

/* initial scan through the devices */

for (i = 1; i < 16; i++) {

- command = (int) (0x0f | ((int) (i & 0x000f) << 4)); /* talk R3 */

- result = adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);

- if (0x00 != send_string[0]) { /* anything come back ?? */

- ADBDevTable[++ADBNumDevices].devType = (u_char) send_string[2];

+ command = ADBTALK(i, 3);

+ result = adb_op_sync((Ptr)send_string, (Ptr)0,

+ (Ptr)0, (short)command);

+ if (result == 0 && send_string[0] != 0) {

+ /* found a device */

+ ++ADBNumDevices;

+ KASSERT(ADBNumDevices < 16);

+ ADBDevTable[ADBNumDevices].devType =

+ (int)(send_string[2]);

ADBDevTable[ADBNumDevices].origAddr = i;

ADBDevTable[ADBNumDevices].currentAddr = i;

- ADBDevTable[ADBNumDevices].DataAreaAddr = (long) 0;

- ADBDevTable[ADBNumDevices].ServiceRtPtr = (void *) 0;

- /* printf_intr("initial device found (at index %i)\n",

- * ADBNumDevices); */

+ ADBDevTable[ADBNumDevices].DataAreaAddr =

+ (long)0;

+ ADBDevTable[ADBNumDevices].ServiceRtPtr = (void *)0;

pm_check_adb_devices(i); /* tell pm driver device

* is here */

}

@@ -1794,128 +2088,241 @@ adb_reinit(void)

if (-1 == get_adb_info(&data, saveptr))

break;

- if (saveptr == 0) /* no free addresses??? */

- saveptr = 15;

- /* printf_intr("first free is: 0x%02x\n", saveptr); */

- /* printf_intr("devices: %i\n", ADBNumDevices); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80) {

+ printf_intr("first free is: 0x%02x\n", saveptr);

+ printf_intr("devices: %i\n", ADBNumDevices);

+ }

+#endif

nonewtimes = 0; /* no loops w/o new devices */

- while (nonewtimes++ < 11) {

- for (i = 1; i <= ADBNumDevices; i++) {

+ while (saveptr > 0 && nonewtimes++ < 11) {

+ for (i = 1;saveptr > 0 && i <= ADBNumDevices; i++) {

device = ADBDevTable[i].currentAddr;

- /* printf_intr("moving device 0x%02x to 0x%02x (index

- * 0x%02x) ", device, saveptr, i); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("moving device 0x%02x to 0x%02x "

+ "(index 0x%02x) ", device, saveptr, i);

+#endif

/* send TALK R3 to address */

- command = (int) (0x0f | ((int) (device & 0x000f) << 4));

- adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);

+ command = ADBTALK(device, 3);

+ (void)adb_op_sync((Ptr)send_string, (Ptr)0,

+ (Ptr)0, (short)command);

/* move device to higher address */

- command = (int) (0x0b | ((int) (device & 0x000f) << 4));

+ command = ADBLISTEN(device, 3);

send_string[0] = 2;

- send_string[1] = (u_char) (saveptr | 0x60);

+ send_string[1] = (u_char)(saveptr | 0x60);

send_string[2] = 0xfe;

- adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);

+ (void)adb_op_sync((Ptr)send_string, (Ptr)0,

+ (Ptr)0, (short)command);

+ delay(1000);

+ /* send TALK R3 - anthing at new address? */

+ command = ADBTALK(saveptr, 3);

+ send_string[0] = 0;

+ result = adb_op_sync((Ptr)send_string, (Ptr)0,

+ (Ptr)0, (short)command);

+ delay(1000);

+ if (result != 0 || send_string[0] == 0) {

+ /*

+ * maybe there's a communication breakdown;

+ * just in case, move it back from whence it

+ * came, and we'll try again later

+ */

+ command = ADBLISTEN(saveptr, 3);

+ send_string[0] = 2;

+ send_string[1] = (u_char)(device | 0x60);

+ send_string[2] = 0x00;

+ (void)adb_op_sync((Ptr)send_string, (Ptr)0,

+ (Ptr)0, (short)command);

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("failed, continuing\n");

+#endif

+ delay(1000);

+ continue;

+ }

/* send TALK R3 - anything at old address? */

- command = (int) (0x0f | ((int) (device & 0x000f) << 4));

- result = adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);

- if (send_string[0] != 0) {

+ command = ADBTALK(device, 3);

+ send_string[0] = 0;

+ result = adb_op_sync((Ptr)send_string, (Ptr)0,

+ (Ptr)0, (short)command);

+ if (result == 0 && send_string[0] != 0) {

/* new device found */

/* update data for previously moved device */

ADBDevTable[i].currentAddr = saveptr;

- /* printf_intr("old device at index %i\n",i); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("old device at index %i\n",i);

+#endif

/* add new device in table */

- /* printf_intr("new device found\n"); */

- ADBDevTable[++ADBNumDevices].devType = (u_char) send_string[2];

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("new device found\n");

+#endif

+ if (saveptr > ADBNumDevices) {

+ ++ADBNumDevices;

+ KASSERT(ADBNumDevices < 16);

+ }

+ ADBDevTable[ADBNumDevices].devType =

+ (int)(send_string[2]);

ADBDevTable[ADBNumDevices].origAddr = device;

ADBDevTable[ADBNumDevices].currentAddr = device;

/* These will be set correctly in adbsys.c */

/* Until then, unsol. data will be ignored. */

- ADBDevTable[ADBNumDevices].DataAreaAddr = (long) 0;

- ADBDevTable[ADBNumDevices].ServiceRtPtr = (void *) 0;

+ ADBDevTable[ADBNumDevices].DataAreaAddr =

+ (long)0;

+ ADBDevTable[ADBNumDevices].ServiceRtPtr =

+ (void *)0;

/* find next unused address */

- for (x = saveptr; x > 0; x--)

+ for (x = saveptr; x > 0; x--) {

if (-1 == get_adb_info(&data, x)) {

saveptr = x;

break;

}

- /* printf_intr("new free is 0x%02x\n",

- * saveptr); */

+ }

+ if (x == 0)

+ saveptr = 0;

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("new free is 0x%02x\n",

+ saveptr);

+#endif

nonewtimes = 0;

/* tell pm driver device is here */

pm_check_adb_devices(device);

} else {

- /* printf_intr("moving back...\n"); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("moving back...\n");

+#endif

/* move old device back */

- command = (int) (0x0b | ((int) (saveptr & 0x000f) << 4));

+ command = ADBLISTEN(saveptr, 3);

send_string[0] = 2;

- send_string[1] = (u_char) (device | 0x60);

+ send_string[1] = (u_char)(device | 0x60);

send_string[2] = 0xfe;

- adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);

+ (void)adb_op_sync((Ptr)send_string, (Ptr)0,

+ (Ptr)0, (short)command);

+ delay(1000);

}

-#ifdef DEBUG

- for (i = 1; i <= ADBNumDevices; i++) {

- x = get_ind_adb_info(&data, i);

- if (x != -1)

- printf_intr("index 0x%x, addr 0x%x, type 0x%x\n", i, x, data.devType);

+#ifdef ADB_DEBUG

+ if (adb_debug) {

+ for (i = 1; i <= ADBNumDevices; i++) {

+ x = get_ind_adb_info(&data, i);

+ if (x != -1)

+ printf_intr("index 0x%x, addr 0x%x, type 0x%hx\n",

+ i, x, data.devType);

+ }

}

#endif

- adb_prog_switch_enable(); /* enable the programmer's switch, if

- * we have one */

+#ifndef MRG_ADB

+ /* enable the programmer's switch, if we have one */

+ adb_prog_switch_enable();

+#endif

- if (0 == ADBNumDevices) /* tell user if no devices found */

- printf_intr("adb: no devices found\n");

+#ifdef ADB_DEBUG

+ if (adb_debug) {

+ if (0 == ADBNumDevices) /* tell user if no devices found */

+ printf_intr("adb: no devices found\n");

+ }

+#endif

adbStarting = 0; /* not starting anymore */

- printf_intr("adb: ADBReInit complete\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: ADBReInit complete\n");

+#endif

- if (adbHardware != ADB_HW_PB) /* ints must be on for PB? */

+ if (adbHardware == ADB_HW_CUDA) {

+ timeout_set(&adb_cuda_timeout, (void *)adb_cuda_tickle, NULL);

+ timeout_add(&adb_cuda_timeout, ADB_TICKLE_TICKS);

+ }

+ /* ints must be on for PB & IOP (at least, for now) */

+ if (adbHardware != ADB_HW_PB)

splx(s);

return;

}

-/* adb_cmd_result

- * This routine lets the caller know whether the specified adb command string should

- * expect a returned result, such as a TALK command.

+/*

+ * adb_comp_exec

+ * This is a general routine that calls the completion routine if there is one.

+ * NOTE: This routine is now only used by pm_direct.c

+ * All the code in this file (adb_direct.c) uses

+ * the adb_pass_up routine now.

+ */

+void

+adb_comp_exec(void)

+ if ((long)0 != adbCompRout) /* don't call if empty return location */

+#if defined(__NetBSD__) || defined(__OpenBSD__)

+ __asm __volatile(

+ " movml #0xffff,sp@- \n" /* save all registers */

+ " movl %0,a2 \n" /* adbCompData */

+ " movl %1,a1 \n" /* adbCompRout */

+ " movl %2,a0 \n" /* adbBuffer */

+ " movl %3,d0 \n" /* adbWaitingCmd */

+ " jbsr a1@ \n" /* go call the routine */

+ " movml sp@+,#0xffff" /* restore all registers */

+ :

+ : "g"(adbCompData), "g"(adbCompRout),

+ "g"(adbBuffer), "g"(adbWaitingCmd)

+ : "d0", "a0", "a1", "a2");

+#else /* for Mac OS-based testing */

+ asm {

+ movem.l a0/a1/a2/d0, -(a7)

+ move.l adbCompData, a2

+ move.l adbCompRout, a1

+ move.l adbBuffer, a0

+ move.w adbWaitingCmd, d0

+ jsr(a1)

+ movem.l(a7) +, d0/a2/a1/a0

+ }

+#endif

+/*

+ * adb_cmd_result

+ *

+ * This routine lets the caller know whether the specified adb command string

+ * should expect a returned result, such as a TALK command.

+ *

* returns: 0 if a result should be expected

* 1 if a result should NOT be expected

int

-adb_cmd_result(u_char * in)

+adb_cmd_result(u_char *in)

{

switch (adbHardware) {

- case ADB_HW_II:

+ case ADB_HW_II:

/* was it an ADB talk command? */

if ((in[1] & 0x0c) == 0x0c)

return 0;

- else

- return 1;

- break;

+ return 1;

case ADB_HW_IISI:

case ADB_HW_CUDA:

- /* was is an ADB talk command? */

+ /* was it an ADB talk command? */

if ((in[1] == 0x00) && ((in[2] & 0x0c) == 0x0c))

return 0;

- /* was is an RTC/PRAM read date/time? */

- else

- if ((in[1] == 0x01) && (in[2] == 0x03))

- return 0;

- else

- return 1;

- break;

+ /* was it an RTC/PRAM read date/time? */

+ if ((in[1] == 0x01) && (in[2] == 0x03))

+ return 0;

+ return 1;

case ADB_HW_PB:

return 1;

- break;

case ADB_HW_UNKNOWN:

default:

@@ -1924,36 +2331,37 @@ adb_cmd_result(u_char * in)

}

-/* adb_cmd_extra

- * This routine lets the caller know whether the specified adb command string may have

- * extra data appended to the end of it, such as a LISTEN command.

+/*

+ * adb_cmd_extra

+ *

+ * This routine lets the caller know whether the specified adb command string

+ * may have extra data appended to the end of it, such as a LISTEN command.

+ *

* returns: 0 if extra data is allowed

* 1 if extra data is NOT allowed

int

-adb_cmd_extra(u_char * in)

+adb_cmd_extra(u_char *in)

{

switch (adbHardware) {

- case ADB_HW_II:

+ case ADB_HW_II:

if ((in[1] & 0x0c) == 0x08) /* was it a listen command? */

return 0;

- else

- return 1;

- break;

+ return 1;

case ADB_HW_IISI:

case ADB_HW_CUDA:

- /* TO DO: support needs to be added to recognize RTC and PRAM

- * commands */

+ /*

+ * TO DO: support needs to be added to recognize RTC and PRAM

+ * commands

+ */

if ((in[2] & 0x0c) == 0x08) /* was it a listen command? */

return 0;

- else /* add others later */

- return 1;

- break;

+ /* add others later */

+ return 1;

case ADB_HW_PB:

return 1;

- break;

case ADB_HW_UNKNOWN:

default:

@@ -1962,41 +2370,6 @@ adb_cmd_extra(u_char * in)

}

-/* adb_op_sync

- * This routine does exactly what the adb_op routine does, except that after the

- * adb_op is called, it waits until the return value is present before returning

- */

-int

-adb_op_sync(Ptr buffer, Ptr compRout, Ptr data, short command)

- int result;

- volatile int flag = 0;

- result = adb_op(buffer, (void *) adb_op_comprout,

- (void *) &flag, command); /* send command */

- if (result == 0) { /* send ok? */

- while (0 == flag); /* wait for compl. routine */

- return 0;

- } else

- return result;

-/* adb_op_comprout

- * This function is used by the adb_op_sync routine so it knows when the function is

- * done.

- */

-void

-adb_op_comprout(void)

-#if defined(__NetBSD__) || defined(__OpenBSD__)

- asm("movw #1,a2@ | update flag value");

-#else /* for macos based testing */

- asm {

- move.w #1,(a2) } /* update flag value */

-#endif

void

adb_setup_hw_type(void)

{

@@ -2004,75 +2377,127 @@ adb_setup_hw_type(void)

response = mac68k_machine.machineid;

+ /*

+ * Determine what type of ADB hardware we are running on.

+ */

switch (response) {

- case 6: /* II */

- case 7: /* IIx */

- case 8: /* IIcx */

- case 9: /* SE/30 */

- case 11: /* IIci */

- case 22: /* Quadra 700 */

- case 30: /* Centris 650 */

- case 35: /* Quadra 800 */

- case 36: /* Quadra 650 */

- case 52: /* Centris 610 */

- case 53: /* Quadra 610 */

+ case MACH_MACC610: /* Centris 610 */

+ case MACH_MACC650: /* Centris 650 */

+ case MACH_MACII: /* II */

+ case MACH_MACIICI: /* IIci */

+ case MACH_MACIICX: /* IIcx */

+ case MACH_MACIIX: /* IIx */

+ case MACH_MACQ610: /* Quadra 610 */

+ case MACH_MACQ650: /* Quadra 650 */

+ case MACH_MACQ700: /* Quadra 700 */

+ case MACH_MACQ800: /* Quadra 800 */

+ case MACH_MACSE30: /* SE/30 */

adbHardware = ADB_HW_II;

- printf_intr("adb: using II series hardware support\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: using II series hardware support\n");

+#endif

break;

- case 18: /* IIsi */

- case 20: /* Quadra 900 - not sure if IIsi or not */

- case 23: /* Classic II */

- case 26: /* Quadra 950 - not sure if IIsi or not */

- case 27: /* LC III, Performa 450 */

- case 37: /* LC II, Performa 400/405/430 */

- case 44: /* IIvi */

- case 45: /* Performa 600 */

- case 48: /* IIvx */

- case 49: /* Color Classic - not sure if IIsi or not */

- case 62: /* Performa 460/465/467 */

- case 83: /* Color Classic II - not sure if IIsi or not */

+ case MACH_MACCLASSICII: /* Classic II */

+ case MACH_MACLCII: /* LC II, Performa 400/405/430 */

+ case MACH_MACLCIII: /* LC III, Performa 450 */

+ case MACH_MACIISI: /* IIsi */

+ case MACH_MACIIVI: /* IIvi */

+ case MACH_MACIIVX: /* IIvx */

+ case MACH_MACP460: /* Performa 460/465/467 */

+ case MACH_MACP600: /* Performa 600 */

adbHardware = ADB_HW_IISI;

- printf_intr("adb: using IIsi series hardware support\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: using IIsi series hardware support\n");

+#endif

break;

- case 21: /* PowerBook 170 */

- case 25: /* PowerBook 140 */

- case 54: /* PowerBook 145 */

- case 34: /* PowerBook 160 */

- case 84: /* PowerBook 165 */

- case 50: /* PowerBook 165c */

- case 33: /* PowerBook 180 */

- case 71: /* PowerBook 180c */

- case 115: /* PowerBook 150 */

+ case MACH_MACPB140: /* PowerBook 140 */

+ case MACH_MACPB145: /* PowerBook 145 */

+ case MACH_MACPB160: /* PowerBook 160 */

+ case MACH_MACPB165: /* PowerBook 165 */

+ case MACH_MACPB165C: /* PowerBook 165c */

+ case MACH_MACPB170: /* PowerBook 170 */

+ case MACH_MACPB180: /* PowerBook 180 */

+ case MACH_MACPB180C: /* PowerBook 180c */

adbHardware = ADB_HW_PB;

pm_setup_adb();

- printf_intr("adb: using PowerBook 100-series hardware support\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: using PowerBook 100-series hardware support\n");

+#endif

break;

- case 29: /* PowerBook Duo 210 */

- case 32: /* PowerBook Duo 230 */

- case 38: /* PowerBook Duo 250 */

- case 72: /* PowerBook 500 series */

- case 77: /* PowerBook Duo 270 */

- case 102: /* PowerBook Duo 280 */

- case 103: /* PowerBook Duo 280c */

+ case MACH_MACPB150: /* PowerBook 150 */

+ case MACH_MACPB210: /* PowerBook Duo 210 */

+ case MACH_MACPB230: /* PowerBook Duo 230 */

+ case MACH_MACPB250: /* PowerBook Duo 250 */

+ case MACH_MACPB270: /* PowerBook Duo 270 */

+ case MACH_MACPB280: /* PowerBook Duo 280 */

+ case MACH_MACPB280C: /* PowerBook Duo 280c */

+ case MACH_MACPB500: /* PowerBook 500 series */

+ case MACH_MACPB190: /* PowerBook 190 */

+ case MACH_MACPB190CS: /* PowerBook 190cs */

adbHardware = ADB_HW_PB;

pm_setup_adb();

- printf_intr("adb: using PowerBook Duo-series and PowerBook 500-series hardware support\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: using PowerBook Duo-series and PowerBook 500-series hardware support\n");

+#endif

break;

- case 56: /* LC 520 */

- case 60: /* Centris 660AV */

- case 78: /* Quadra 840AV */

- case 80: /* LC 550, Performa 550 */

- case 89: /* LC 475, Performa 475/476 */

- case 92: /* LC 575, Performa 575/577/578 */

- case 94: /* Quadra 605 */

- case 98: /* LC 630, Performa 630, Quadra 630 */

+ case MACH_MACC660AV: /* Centris 660AV */

+ case MACH_MACCCLASSIC: /* Color Classic */

+ case MACH_MACCCLASSICII: /* Color Classic II */

+ case MACH_MACLC475: /* LC 475, Performa 475/476 */

+ case MACH_MACLC475_33: /* Clock-chipped 47x */

+ case MACH_MACLC520: /* LC 520 */

+ case MACH_MACLC575: /* LC 575, Performa 575/577/578 */

+ case MACH_MACP550: /* LC 550, Performa 550 */

+ case MACH_MACTV: /* Macintosh TV */

+ case MACH_MACP580: /* Performa 580/588 */

+ case MACH_MACQ605: /* Quadra 605 */

+ case MACH_MACQ605_33: /* Clock-chipped Quadra 605 */

+ case MACH_MACQ630: /* LC 630, Performa 630, Quadra 630 */

+ case MACH_MACQ840AV: /* Quadra 840AV */

adbHardware = ADB_HW_CUDA;

- printf_intr("adb: using Cuda series hardware support\n");

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf_intr("adb: using Cuda series hardware support\n");

+#endif

break;

default:

adbHardware = ADB_HW_UNKNOWN;

- printf_intr("adb: hardware type unknown for this machine\n");

- printf_intr("adb: ADB support is disabled\n");

+#ifdef ADB_DEBUG

+ if (adb_debug) {

+ printf_intr("adb: hardware type unknown for this machine\n");

+ printf_intr("adb: ADB support is disabled\n");

+ }

+#endif

+ break;

+ }

+ /*

+ * Determine whether this machine has ADB based soft power.

+ */

+ switch (response) {

+ case MACH_MACCCLASSIC: /* Color Classic */

+ case MACH_MACCCLASSICII: /* Color Classic II */

+ case MACH_MACIISI: /* IIsi */

+ case MACH_MACIIVI: /* IIvi */

+ case MACH_MACIIVX: /* IIvx */

+ case MACH_MACLC520: /* LC 520 */

+ case MACH_MACLC575: /* LC 575, Performa 575/577/578 */

+ case MACH_MACP550: /* LC 550, Performa 550 */

+ case MACH_MACTV: /* Macintosh TV */

+ case MACH_MACP580: /* Performa 580/588 */

+ case MACH_MACP600: /* Performa 600 */

+ case MACH_MACQ630: /* LC 630, Performa 630, Quadra 630 */

+ case MACH_MACQ840AV: /* Quadra 840AV */

+ adbSoftPower = 1;

break;

}

@@ -2086,33 +2511,36 @@ count_adbs(void)

found = 0;

for (i = 1; i < 16; i++)

- if (0 != ADBDevTable[i].devType)

+ if (0 != ADBDevTable[i].currentAddr)

found++;

return found;

}

int

-get_ind_adb_info(ADBDataBlock * info, int index)

+get_ind_adb_info(ADBDataBlock *info, int index)

{

if ((index < 1) || (index > 15)) /* check range 1-15 */

return (-1);

- /* printf_intr("index 0x%x devType is: 0x%x\n", index,

- ADBDevTable[index].devType); */

+#ifdef ADB_DEBUG

+ if (adb_debug & 0x80)

+ printf_intr("index 0x%x devType is: 0x%x\n", index,

+ ADBDevTable[index].devType);

+#endif

if (0 == ADBDevTable[index].devType) /* make sure it's a valid entry */

return (-1);

- info->devType = ADBDevTable[index].devType;

- info->origADBAddr = ADBDevTable[index].origAddr;

- info->dbServiceRtPtr = (Ptr) ADBDevTable[index].ServiceRtPtr;

- info->dbDataAreaAddr = (Ptr) ADBDevTable[index].DataAreaAddr;

+ info->devType = (unsigned char)(ADBDevTable[index].devType);

+ info->origADBAddr = (unsigned char)(ADBDevTable[index].origAddr);

+ info->dbServiceRtPtr = (Ptr)ADBDevTable[index].ServiceRtPtr;

+ info->dbDataAreaAddr = (Ptr)ADBDevTable[index].DataAreaAddr;

return (ADBDevTable[index].currentAddr);

}

int

-get_adb_info(ADBDataBlock * info, int adbAddr)

+get_adb_info(ADBDataBlock *info, int adbAddr)

{

int i;

@@ -2121,8 +2549,8 @@ get_adb_info(ADBDataBlock * info, int adbAddr)

for (i = 1; i < 15; i++)

if (ADBDevTable[i].currentAddr == adbAddr) {

- info->devType = ADBDevTable[i].devType;

- info->origADBAddr = ADBDevTable[i].origAddr;

+ info->devType = (unsigned char)(ADBDevTable[i].devType);

+ info->origADBAddr = (unsigned char)(ADBDevTable[i].origAddr);

info->dbServiceRtPtr = (Ptr)ADBDevTable[i].ServiceRtPtr;

info->dbDataAreaAddr = ADBDevTable[i].DataAreaAddr;

return 0; /* found */

@@ -2132,7 +2560,7 @@ get_adb_info(ADBDataBlock * info, int adbAddr)

}

int

-set_adb_info(ADBSetInfoBlock * info, int adbAddr)

+set_adb_info(ADBSetInfoBlock *info, int adbAddr)

{

int i;

@@ -2155,24 +2583,23 @@ set_adb_info(ADBSetInfoBlock * info, int adbAddr)

int

mrg_adbintr(void)

{

- adb_intr();

+ adb_intr(NULL);

return 1; /* mimic mrg_adbintr in macrom.h just in case */

}

int

-mrg_pmintr(void) /* we don't do this yet */

+mrg_pmintr(void)

{

- pm_intr();

+ pm_intr(NULL);

return 1; /* mimic mrg_pmintr in macrom.h just in case */

}

-#endif

-/* caller should really use machine-independent version: getPramTime */

+/* caller should really use machine-independant version: getPramTime */

/* this version does pseudo-adb access only */

int

adb_read_date_time(unsigned long *time)

{

- u_char output[MAX_ADB_MSG_LENGTH];

+ u_char output[ADB_MAX_MSG_LENGTH];

int result;

volatile int flag = 0;

@@ -2184,16 +2611,15 @@ adb_read_date_time(unsigned long *time)

output[0] = 0x02; /* 2 byte message */

output[1] = 0x01; /* to pram/rtc device */

output[2] = 0x03; /* read date/time */

- result = send_adb_IIsi((u_char *) output,

- (u_char *) output, (void *) adb_op_comprout,

- (int *) &flag, (int) 0);

+ result = send_adb_IIsi((u_char *)output, (u_char *)output,

+ (void *)adb_op_comprout, (void *)&flag, (int)0);

if (result != 0) /* exit if not sent */

return -1;

while (0 == flag) /* wait for result */

;

- *time = (long) (*(long *) (output + 1));

+ *time = (long)(*(long *)(output + 1));

return 0;

case ADB_HW_PB:

@@ -2203,16 +2629,15 @@ adb_read_date_time(unsigned long *time)

output[0] = 0x02; /* 2 byte message */

output[1] = 0x01; /* to pram/rtc device */

output[2] = 0x03; /* read date/time */

- result = send_adb_cuda((u_char *) output,

- (u_char *) output, (void *) adb_op_comprout,

- (void *) &flag, (int) 0);

+ result = send_adb_cuda((u_char *)output, (u_char *)output,

+ (void *)adb_op_comprout, (void *)&flag, (int)0);

if (result != 0) /* exit if not sent */

return -1;

while (0 == flag) /* wait for result */

;

- *time = (long) (*(long *) (output + 1));

+ *time = (long)(*(long *)(output + 1));

return 0;

case ADB_HW_UNKNOWN:

@@ -2221,12 +2646,12 @@ adb_read_date_time(unsigned long *time)

}

-/* caller should really use machine-independent version: setPramTime */

+/* caller should really use machine-independant version: setPramTime */

/* this version does pseudo-adb access only */

int

adb_set_date_time(unsigned long time)

{

- u_char output[MAX_ADB_MSG_LENGTH];

+ u_char output[ADB_MAX_MSG_LENGTH];

int result;

volatile int flag = 0;

@@ -2238,13 +2663,12 @@ adb_set_date_time(unsigned long time)

output[0] = 0x06; /* 6 byte message */

output[1] = 0x01; /* to pram/rtc device */

output[2] = 0x09; /* set date/time */

- output[3] = (u_char) (time >> 24);

- output[4] = (u_char) (time >> 16);

- output[5] = (u_char) (time >> 8);

- output[6] = (u_char) (time);

- result = send_adb_IIsi((u_char *) output,

- (u_char *) 0, (void *) adb_op_comprout,

- (void *) &flag, (int) 0);

+ output[3] = (u_char)(time >> 24);

+ output[4] = (u_char)(time >> 16);

+ output[5] = (u_char)(time >> 8);

+ output[6] = (u_char)(time);

+ result = send_adb_IIsi((u_char *)output, (u_char *)0,

+ (void *)adb_op_comprout, (void *)&flag, (int)0);

if (result != 0) /* exit if not sent */

return -1;

@@ -2260,13 +2684,12 @@ adb_set_date_time(unsigned long time)

output[0] = 0x06; /* 6 byte message */

output[1] = 0x01; /* to pram/rtc device */

output[2] = 0x09; /* set date/time */

- output[3] = (u_char) (time >> 24);

- output[4] = (u_char) (time >> 16);

- output[5] = (u_char) (time >> 8);

- output[6] = (u_char) (time);

- result = send_adb_cuda((u_char *) output,

- (u_char *) 0, (void *) adb_op_comprout,

- (void *) &flag, (int) 0);

+ output[3] = (u_char)(time >> 24);

+ output[4] = (u_char)(time >> 16);

+ output[5] = (u_char)(time >> 8);

+ output[6] = (u_char)(time);

+ result = send_adb_cuda((u_char *)output, (u_char *)0,

+ (void *)adb_op_comprout, (void *)&flag, (int)0);

if (result != 0) /* exit if not sent */

return -1;

@@ -2285,16 +2708,21 @@ adb_set_date_time(unsigned long time)

int

adb_poweroff(void)

{

- u_char output[MAX_ADB_MSG_LENGTH];

+ u_char output[ADB_MAX_MSG_LENGTH];

int result;

+ if (!adbSoftPower)

+ return -1;

+ adb_polling = 1;

switch (adbHardware) {

case ADB_HW_IISI:

output[0] = 0x02; /* 2 byte message */

output[1] = 0x01; /* to pram/rtc/soft-power device */

output[2] = 0x0a; /* set date/time */

- result = send_adb_IIsi((u_char *) output,

- (u_char *) 0, (void *) 0, (void *) 0, (int) 0);

+ result = send_adb_IIsi((u_char *)output, (u_char *)0,

+ (void *)0, (void *)0, (int)0);

if (result != 0) /* exit if not sent */

return -1;

@@ -2305,9 +2733,20 @@ adb_poweroff(void)

case ADB_HW_PB:

return -1;

- /* TO DO: some cuda models claim to do soft power - check out */

- case ADB_HW_II: /* II models don't do soft power */

- case ADB_HW_CUDA: /* cuda doesn't do soft power */

+ case ADB_HW_CUDA:

+ output[0] = 0x02; /* 2 byte message */

+ output[1] = 0x01; /* to pram/rtc/soft-power device */

+ output[2] = 0x0a; /* set date/time */

+ result = send_adb_cuda((u_char *)output, (u_char *)0,

+ (void *)0, (void *)0, (int)0);

+ if (result != 0) /* exit if not sent */

+ return -1;

+ for (;;); /* wait for power off */

+ return 0;

+ case ADB_HW_II: /* II models don't do ADB soft power */

case ADB_HW_UNKNOWN:

default:

return -1;

@@ -2317,7 +2756,7 @@ adb_poweroff(void)

int

adb_prog_switch_enable(void)

{

- u_char output[MAX_ADB_MSG_LENGTH];

+ u_char output[ADB_MAX_MSG_LENGTH];

int result;

volatile int flag = 0;

@@ -2327,9 +2766,8 @@ adb_prog_switch_enable(void)

output[1] = 0x01; /* to pram/rtc/soft-power device */

output[2] = 0x1c; /* prog. switch control */

output[3] = 0x01; /* enable */

- result = send_adb_IIsi((u_char *) output,

- (u_char *) 0, (void *) adb_op_comprout,

- (void *) &flag, (int) 0);

+ result = send_adb_IIsi((u_char *)output, (u_char *)0,

+ (void *)adb_op_comprout, (void *)&flag, (int)0);

if (result != 0) /* exit if not sent */

return -1;

@@ -2352,7 +2790,7 @@ adb_prog_switch_enable(void)

int

adb_prog_switch_disable(void)

{

- u_char output[MAX_ADB_MSG_LENGTH];

+ u_char output[ADB_MAX_MSG_LENGTH];

int result;

volatile int flag = 0;

@@ -2362,9 +2800,8 @@ adb_prog_switch_disable(void)

output[1] = 0x01; /* to pram/rtc/soft-power device */

output[2] = 0x1c; /* prog. switch control */

output[3] = 0x01; /* disable */

- result = send_adb_IIsi((u_char *) output,

- (u_char *) 0, (void *) adb_op_comprout,

- (void *) &flag, (int) 0);

+ result = send_adb_IIsi((u_char *)output, (u_char *)0,

+ (void *)adb_op_comprout, (void *)&flag, (int)0);

if (result != 0) /* exit if not sent */

return -1;

@@ -2384,8 +2821,6 @@ adb_prog_switch_disable(void)

}

-#ifndef MRG_ADB

int

CountADBs(void)

{

@@ -2399,19 +2834,19 @@ ADBReInit(void)

}

int

-GetIndADB(ADBDataBlock * info, int index)

+GetIndADB(ADBDataBlock *info, int index)

{

return (get_ind_adb_info(info, index));

}

int

-GetADBInfo(ADBDataBlock * info, int adbAddr)

+GetADBInfo(ADBDataBlock *info, int adbAddr)

{

return (get_adb_info(info, adbAddr));

}

int

-SetADBInfo(ADBSetInfoBlock * info, int adbAddr)

+SetADBInfo(ADBSetInfoBlock *info, int adbAddr)

{

return (set_adb_info(info, adbAddr));

}

@@ -2423,4 +2858,3 @@ ADBOp(Ptr buffer, Ptr compRout, Ptr data, short commandNum)

}

#endif

diff --git a/sys/arch/mac68k/dev/adbsys.c b/sys/arch/mac68k/dev/adbsys.c
deleted file mode 100644
index 78bbead2ba5..00000000000
--- a/sys/arch/mac68k/dev/adbsys.c
+++ /dev/null

@@ -1,315 +0,0 @@

-/* $OpenBSD: adbsys.c,v 1.11 2002/03/14 01:26:35 millert Exp $ */

-/* $NetBSD: adbsys.c,v 1.24 1997/01/13 07:01:23 scottr Exp $ */

-/*-

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- * notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- * notice, this list of conditions and the following disclaimer in the

- * documentation and/or other materials provided with the distribution.

- * 3. All advertising materials mentioning features or use of this software

- * must display the following acknowledgement:

- * This product includes software developed by Bradley A. Grantham.

- * 4. The name of the author may not be used to endorse or promote products

- * derived from this software without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- */

-#include <sys/param.h>

-#include <sys/systm.h>

-#include <machine/cpu.h>

-#include <machine/viareg.h>

-#include <arch/mac68k/mac68k/macrom.h>

-#include <arch/mac68k/dev/adbvar.h>

-extern struct mac68k_machine_S mac68k_machine;

-/* from adb.c */

-void adb_processevent(adb_event_t * event);

-extern void adb_jadbproc(void);

-void

-adb_complete(buffer, data_area, adb_command)

- caddr_t buffer;

- caddr_t data_area;

- int adb_command;

- adb_event_t event;

- ADBDataBlock adbdata;

- int adbaddr;

- int error;

-#ifdef MRG_DEBUG

- register int i;

- printf("adb: transaction completion\n");

-#endif

- adbaddr = (adb_command & 0xf0) >> 4;

- error = GetADBInfo(&adbdata, adbaddr);

-#ifdef MRG_DEBUG

- printf("adb: GetADBInfo returned %d\n", error);

-#endif

- event.addr = adbaddr;

- event.hand_id = adbdata.devType;

- event.def_addr = adbdata.origADBAddr;

- event.byte_count = buffer[0];

- memcpy(event.bytes, buffer + 1, event.byte_count);

-#ifdef MRG_DEBUG

- printf("adb: from %d at %d (org %d) %d:", event.addr,

- event.hand_id, event.def_addr, buffer[0]);

- for (i = 1; i <= buffer[0]; i++)

- printf(" %x", buffer[i]);

- printf("\n");

-#endif

- microtime(&event.timestamp);

- adb_processevent(&event);

-static volatile int extdms_done;

-/*

- * initialize extended mouse - probes devices as

- * described in _Inside Macintosh, Devices_.

- */

-void

-extdms_init(totaladbs)

- int totaladbs;

- ADBDataBlock adbdata;

- int adbindex, adbaddr;

- short cmd;

- char buffer[9];

- for (adbindex = 1; adbindex <= totaladbs; adbindex++) {

- /* Get the ADB information */

- adbaddr = GetIndADB(&adbdata, adbindex);

- if (adbdata.origADBAddr == ADBADDR_MS &&

- (adbdata.devType == ADBMS_USPEED)) {

- /* Found MicroSpeed Mouse Deluxe Mac */

- cmd = ((adbaddr<<4)&0xF0)|0x9; /* listen 1 */

- /*

- * To setup the MicroSpeed, it appears that we can

- * send the following command to the mouse and then

- * expect data back in the form:

- * buffer[0] = 4 (bytes)

- * buffer[1], buffer[2] as std. mouse

- * buffer[3] = buffer[4] = 0xff when no buttons

- * are down. When button N down, bit N is clear.

- * buffer[4]'s locking mask enables a

- * click to toggle the button down state--sort of

- * like the "Easy Access" shift/control/etc. keys.

- * buffer[3]'s alternative speed mask enables using

- * different speed when the corr. button is down

- */

- buffer[0] = 4;

- buffer[1] = 0x00; /* Alternative speed */

- buffer[2] = 0x00; /* speed = maximum */

- buffer[3] = 0x10; /* enable extended protocol,

- * lower bits = alt. speed mask

- * = 0000b

- */

- buffer[4] = 0x07; /* Locking mask = 0000b,

- * enable buttons = 0111b

- */

- extdms_done = 0;

- ADBOp((Ptr)buffer, (Ptr)extdms_complete,

- (Ptr)&extdms_done, cmd);

- while (!extdms_done)

- /* busy wait until done */;

- }

- if (adbdata.origADBAddr == ADBADDR_MS &&

- ( adbdata.devType == ADBMS_100DPI

- || adbdata.devType == ADBMS_200DPI)) {

- /* found a mouse */

- cmd = ((adbaddr << 4) & 0xf0) | 0x3;

- extdms_done = 0;

- cmd = (cmd & 0xf3) | 0x0c; /* talk command */

- ADBOp((Ptr)buffer, (Ptr)extdms_complete,

- (Ptr)&extdms_done, cmd);

- while (!extdms_done)

- /* busy wait until done */;

- buffer[2] = '\004'; /* make handler ID 4 */

- extdms_done = 0;

- cmd = (cmd & 0xf3) | 0x08; /* listen command */

- ADBOp((Ptr)buffer, (Ptr)extdms_complete,

- (Ptr)&extdms_done, cmd);

- while (!extdms_done)

- /* busy wait until done */;

- }

-void

-adb_init()

- ADBDataBlock adbdata;

- ADBSetInfoBlock adbinfo;

- int totaladbs;

- int adbindex, adbaddr;

- int error;

- char buffer[9];

-#ifdef DISABLE_ADB_WHEN_SERIAL_CONSOLE

- if ((mac68k_machine.serial_console & 0x03)) {

- printf("adb: using serial console\n");

- return;

- }

-#endif

-#ifdef MRG_ADB /* We don't care about ADB ROM driver if we

- * aren't using the MRG_ADB method for

- * ADB/PRAM/RTC. */

- if (!mrg_romready()) {

- printf("adb: no ROM ADB driver in this kernel for this machine\n");

- return;

- }

-#endif

- printf("adb: bus subsystem\n");

-#ifdef MRG_DEBUG

- printf("adb: call mrg_initadbintr\n");

-#endif

- mrg_initadbintr(); /* Mac ROM Glue okay to do ROM intr */

-#ifdef MRG_DEBUG

- printf("adb: returned from mrg_initadbintr\n");

-#endif

- /* ADBReInit pre/post-processing */

- JADBProc = adb_jadbproc;

- /*

- * Initialize ADB

- *

- * If not using MRG_ADB method to access ADB, then call

- * ADBReInit directly. Otherwise use ADB AlternateInit()

- */

-#ifndef MRG_ADB

- printf("adb: calling ADBReInit\n");

- ADBReInit();

-#else

-#ifdef MRG_DEBUG

- printf("adb: calling ADBAlternateInit.\n");

-#endif

- ADBAlternateInit();

-#endif

-#ifdef MRG_DEBUG

- printf("adb: done with ADBReInit\n");

-#endif

- totaladbs = CountADBs();

- extdms_init(totaladbs);

- /* for each ADB device */

- for (adbindex = 1; adbindex <= totaladbs; adbindex++) {

- /* Get the ADB information */

- adbaddr = GetIndADB(&adbdata, adbindex);

- /* Print out the glory */

- printf("adb: ");

- switch (adbdata.origADBAddr) {

- case ADBADDR_MAP:

- switch (adbdata.devType) {

- case ADB_STDKBD:

- printf("keyboard");

- break;

- case ADB_EXTKBD:

- printf("extended keyboard");

- break;

- case ADB_PBKBD:

- printf("PowerBook keyboard");

- break;

- default:

- printf("mapped device (%d)",

- adbdata.devType);

- break;

- }

- break;

- case ADBADDR_REL:

- extdms_done = 0;

- /* talk register 3 */

- ADBOp((Ptr)buffer, (Ptr)extdms_complete,

- (Ptr)&extdms_done, (adbaddr << 4) | 0xf);

- while (!extdms_done)

- /* busy-wait until done */;

- switch (buffer[2]) {

- case ADBMS_100DPI:

- printf("100 dpi mouse");

- break;

- case ADBMS_200DPI:

- printf("200 dpi mouse");

- break;

- case ADBMS_USPEED:

- printf("MicroSpeed mouse, default parameters");

- break;

- case ADBMS_EXTENDED:

- extdms_done = 0;

- /* talk register 1 */

- ADBOp((Ptr)buffer, (Ptr)extdms_complete,

- (Ptr)&extdms_done,

- (adbaddr << 4) | 0xd);

- while (!extdms_done)

- /* busy-wait until done */;

- printf("extended mouse "

- "<%c%c%c%c> %d-button %d dpi ",

- buffer[1], buffer[2],

- buffer[3], buffer[4],

- (int)buffer[8],

- (int)*(short *)&buffer[5]);

- if (buffer[7] == 1)

- printf("mouse");

- else if (buffer[7] == 2)

- printf("trackball");

- else

- printf("unknown device");

- break;

- default:

- printf("relative positioning device (mouse?) (%d)", adbdata.devType);

- break;

- }

- break;

- case ADBADDR_ABS:

- printf("absolute positioning device (tablet?) (%d)", adbdata.devType);

- break;

- default:

- printf("unknown type device, (def %d, handler %d)", adbdata.origADBAddr,

- adbdata.devType);

- break;

- }

- printf(" at %d\n", adbaddr);

- /* Set completion routine to be MacBSD's */

- adbinfo.siServiceRtPtr = (Ptr) adb_asmcomplete;

- adbinfo.siDataAreaAddr = NULL;

- error = SetADBInfo(&adbinfo, adbaddr);

-#ifdef MRG_DEBUG

- printf("returned %d from SetADBInfo\n", error);

-#endif

- }

diff --git a/sys/arch/mac68k/dev/adbsysasm.s b/sys/arch/mac68k/dev/adbsysasm.s
index 478e52a0db3..c5a78df8867 100644
--- a/sys/arch/mac68k/dev/adbsysasm.s
+++ b/sys/arch/mac68k/dev/adbsysasm.s

@@ -1,5 +1,5 @@

-/* $OpenBSD: adbsysasm.s,v 1.2 1996/05/26 18:35:16 briggs Exp $ */

-/* $NetBSD: adbsysasm.s,v 1.2 1995/09/03 20:59:56 briggs Exp $ */

+/* $OpenBSD: adbsysasm.s,v 1.3 2006/01/04 20:39:04 miod Exp $ */

+/* $NetBSD: adbsysasm.s,v 1.11 2001/11/20 03:19:42 chs Exp $ */

/*-

@@ -31,44 +31,62 @@

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+#include "akbd.h"

+#include "ams.h"

+#include <machine/asm.h>

* ADB subsystem routines in assembly

-/* This routine is called when a device has sent us some data. */

+#if NAKBD > 0

+/* This routine is called when a keyboard has sent us some data. */

+/* (provided it has been set up with SetADBInfo) */

+GLOBAL(adb_kbd_asmcomplete)

+ moveml #0x80e0,sp@- | save scratch regs

+ movl d0,sp@- /* ADB command byte */

+ movl a2,sp@- /* data area pointer */

+ /* a1 is the pointer to this routine itself. */

+ movl a0,sp@- /* device data buffer */

+ jbsr _C_LABEL(kbd_adbcomplete)

+ addl #12,sp /* pop params */

+ moveml sp@+,#0x0701 | restore scratch regs

+ rts

+#endif

+#if NAMS > 0

+/* This routine is called when a mouse has sent us some data. */

/* (provided it has been set up with SetADBInfo) */

- .global _adb_asmcomplete

- .global _adb_complete

-_adb_asmcomplete:

- moveml #0xc0c0, sp@- | save scratch regs

- movl d0, sp@- /* ADB command byte */

- movl a2, sp@- /* data area pointer */

+GLOBAL(adb_ms_asmcomplete)

+ moveml #0x80e0,sp@- | save scratch regs

+ movl d0,sp@- /* ADB command byte */

+ movl a2,sp@- /* data area pointer */

/* a1 is the pointer to this routine itself. */

- movl a0, sp@- /* device data buffer */

- jbsr _adb_complete

- addl #12, sp /* pop params */

- moveml sp@+, #0x0303 | restore scratch regs

+ movl a0,sp@- /* device data buffer */

+ jbsr _C_LABEL(ms_adbcomplete)

+ addl #12,sp /* pop params */

+ moveml sp@+,#0x0701 | restore scratch regs

rts

+#endif

+#ifdef MRG_ADB

-_adb_jadbprochello:

+#if defined(ADB_DEBUG) && 0

+GLOBAL(adb_jadbprochello)

.asciz "adb: hello from adbproc\n"

.even

+#endif

- .global _adb_jadbproc

-_adb_jadbproc:

-#if defined(MRG_DEBUG) && 0

- moveml #0xc0c0, sp@- | save scratch regs

- movl _adb_jadbprochello, sp@-

- jbsr _printf

- addl #4, sp /* pop params */

- moveml sp@+, #0x0303 | restore scratch regs

+GLOBAL(adb_jadbproc)

+#if defined(ADB_DEBUG) && 0

+ moveml #0xc0c0,sp@- | save scratch regs

+ movl _C_LABEL(adb_jadbprochello),sp@-

+ jbsr _C_LABEL(printf)

+ addl #4,sp /* pop params */

+ moveml sp@+,#0x0303 | restore scratch regs

#endif

- /* Don't do anything; adb_init fixes dev info for us. */

+ /* Don't do anything; adbattach fixes dev info for us. */

rts

- /* ADBOp's completion routine used by extdms_init() in adbsys.c. */

- .global _extdms_complete

-_extdms_complete:

- movl #-1,a2@ | set done flag

- rts

+#endif /* MRG_ADB */

diff --git a/sys/arch/mac68k/dev/adbvar.h b/sys/arch/mac68k/dev/adbvar.h
index 67e40f1fcbd..e06099a3765 100644
--- a/sys/arch/mac68k/dev/adbvar.h
+++ b/sys/arch/mac68k/dev/adbvar.h

@@ -1,7 +1,7 @@

-/* $OpenBSD: adbvar.h,v 1.8 2003/09/23 16:51:11 millert Exp $ */

-/* $NetBSD: adbvar.h,v 1.5 1997/01/13 07:01:24 scottr Exp $ */

+/* $OpenBSD: adbvar.h,v 1.9 2006/01/04 20:39:04 miod Exp $ */

+/* $NetBSD: adbvar.h,v 1.22 2005/01/15 16:00:59 chs Exp $ */

-/*-

+/*

@@ -31,60 +31,60 @@

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+#include <mac68k/mac68k/macrom.h>

#include <machine/adbsys.h>

-#define ADB_MAXTRACE (NBPG / sizeof(int) - 1)

-extern int adb_traceq[ADB_MAXTRACE];

-extern int adb_traceq_tail;

-extern int adb_traceq_len;

-typedef struct adb_trace_xlate_s {

- int params;

- char *string;

-} adb_trace_xlate_t;

+/*

+ * Arguments used to attach a device to the Apple Desktop Bus

+ */

+struct adb_attach_args {

+ int origaddr;

+ int adbaddr;

+ int handler_id;

+};

-extern adb_trace_xlate_t adb_trace_xlations[];

+extern int adb_polling;

-/* adb.c */

-void adb_asmcomplete(void);

-void adb_enqevent(adb_event_t *event);

-void adb_handoff(adb_event_t *event);

-void adb_autorepeat(void *keyp);

-void adb_dokeyupdown(adb_event_t *event);

-void adb_keymaybemouse(adb_event_t *event);

-void adb_processevent(adb_event_t *event);

-int adbopen(dev_t dev, int flag, int mode, struct proc *p);

-int adbclose(dev_t dev, int flag, int mode, struct proc *p);

-int adbread(dev_t dev, struct uio *uio, int flag);

-int adbwrite(dev_t dev, struct uio *uio, int flag);

-int adbioctl(dev_t , int , caddr_t , int , struct proc *);

-int adbpoll(dev_t dev, int rw, struct proc *p);

+#ifdef DEBUG

+#ifndef ADB_DEBUG

+#define ADB_DEBUG

+#endif

-/* adbsysadm.s */

-void extdms_complete(void);

+#ifdef ADB_DEBUG

+extern int adb_debug;

+#endif

-/* adbsys.c */

-void adb_complete(caddr_t buffer, caddr_t data_area, int adb_command);

-void extdms_init(int);

+/* adb.c */

+int adb_op_sync(Ptr, Ptr, Ptr, short);

+void adb_op_comprout(void);

-#ifndef MRG_ADB

+/* adbsysasm.s */

+void adb_kbd_asmcomplete(void);

+void adb_ms_asmcomplete(void);

/* types of adb hardware that we (will eventually) support */

-#define ADB_HW_UNKNOWN 0x01 /* don't know */

-#define ADB_HW_II 0x02 /* Mac II series */

-#define ADB_HW_IISI 0x03 /* Mac IIsi series */

-#define ADB_HW_PB 0x04 /* PowerBook series */

-#define ADB_HW_CUDA 0x05 /* Machines with a Cuda chip */

+#define ADB_HW_UNKNOWN 0x0 /* don't know */

+#define ADB_HW_II 0x1 /* Mac II series */

+#define ADB_HW_IISI 0x2 /* Mac IIsi series */

+#define ADB_HW_PB 0x3 /* PowerBook series */

+#define ADB_HW_CUDA 0x4 /* Machines with a Cuda chip */

+#define MAX_ADB_HW 4 /* Number of ADB hardware types */

+#define ADB_CMDADDR(cmd) ((u_int8_t)(cmd & 0xf0) >> 4)

+#define ADBFLUSH(dev) ((((u_int8_t)dev & 0x0f) << 4) | 0x01)

+#define ADBLISTEN(dev, reg) ((((u_int8_t)dev & 0x0f) << 4) | 0x08 | reg)

+#define ADBTALK(dev, reg) ((((u_int8_t)dev & 0x0f) << 4) | 0x0c | reg)

+#ifndef MRG_ADB

/* adb_direct.c */

int adb_poweroff(void);

int CountADBs(void);

void ADBReInit(void);

-int GetIndADB(ADBDataBlock * info, int index);

-int GetADBInfo(ADBDataBlock * info, int adbAddr);

-int SetADBInfo(ADBSetInfoBlock * info, int adbAddr);

-int ADBOp(Ptr buffer, Ptr compRout, Ptr data, short commandNum);

-int adb_read_date_time(unsigned long *t);

-int adb_set_date_time(unsigned long t);

-#endif

+int GetIndADB(ADBDataBlock *, int);

+int GetADBInfo(ADBDataBlock *, int);

+int SetADBInfo(ADBSetInfoBlock *, int);

+int ADBOp(Ptr, Ptr, Ptr, short);

+int adb_read_date_time(unsigned long *);

+int adb_set_date_time(unsigned long);

+#endif /* !MRG_ADB */

diff --git a/sys/arch/mac68k/dev/akbd.c b/sys/arch/mac68k/dev/akbd.c
new file mode 100644
index 00000000000..b3f2e9f12c6
--- /dev/null
+++ b/sys/arch/mac68k/dev/akbd.c

@@ -0,0 +1,536 @@

+/* $OpenBSD: akbd.c,v 1.1 2006/01/04 20:39:04 miod Exp $ */

+/* $NetBSD: akbd.c,v 1.17 2005/01/15 16:00:59 chs Exp $ */

+/*

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 1. Redistributions of source code must retain the above copyright

+ * notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above copyright

+ * notice, this list of conditions and the following disclaimer in the

+ * documentation and/or other materials provided with the distribution.

+ * 3. All advertising materials mentioning features or use of this software

+ * must display the following acknowledgement:

+ * This product includes software developed by Colin Wood.

+ * 4. The name of the author may not be used to endorse or promote products

+ * derived from this software without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include <sys/param.h>

+#include <sys/timeout.h>

+#include <sys/kernel.h>

+#include <sys/device.h>

+#include <sys/fcntl.h>

+#include <sys/poll.h>

+#include <sys/selinfo.h>

+#include <sys/proc.h>

+#include <sys/signalvar.h>

+#include <sys/systm.h>

+#include "wskbd.h"

+#include <dev/wscons/wsconsio.h>

+#include <dev/wscons/wskbdvar.h>

+#include <dev/wscons/wsksymdef.h>

+#include <dev/wscons/wsksymvar.h>

+#include <machine/autoconf.h>

+#include <machine/cpu.h>

+#include <machine/viareg.h>

+#include <mac68k/dev/adbvar.h>

+#include <mac68k/dev/akbdmap.h>

+#include <mac68k/dev/akbdvar.h>

+#define KEYBOARD_ARRAY

+#include <machine/keyboard.h>

+/*

+ * Function declarations.

+ */

+int akbdmatch(struct device *, void *, void *);

+void akbdattach(struct device *, struct device *, void *);

+void kbd_adbcomplete(caddr_t, caddr_t, int);

+void kbd_processevent(adb_event_t *, struct akbd_softc *);

+int akbd_is_console(void);

+/* Driver definition. */

+struct cfattach akbd_ca = {

+ sizeof(struct akbd_softc), akbdmatch, akbdattach

+};

+struct cfdriver akbd_cd = {

+ NULL, "akbd", DV_DULL

+};

+int akbd_enable(void *, int);

+void akbd_set_leds(void *, int);

+int akbd_ioctl(void *, u_long, caddr_t, int, struct proc *);

+int akbd_intr(adb_event_t *, struct akbd_softc *);

+void akbd_rawrepeat(void *v);

+struct wskbd_accessops akbd_accessops = {

+ akbd_enable,

+ akbd_set_leds,

+ akbd_ioctl,

+};

+struct wskbd_mapdata akbd_keymapdata = {

+ akbd_keydesctab,

+#ifdef AKBD_LAYOUT

+ AKBD_LAYOUT,

+#else

+ KB_US,

+#endif

+};

+int

+akbdmatch(struct device *parent, void *vcf, void *aux)

+ struct adb_attach_args *aa_args = (struct adb_attach_args *)aux;

+ if (aa_args->origaddr == ADBADDR_KBD)

+ return 1;

+ else

+ return 0;

+void

+akbdattach(struct device *parent, struct device *self, void *aux)

+ ADBSetInfoBlock adbinfo;

+ struct akbd_softc *sc = (struct akbd_softc *)self;

+ struct adb_attach_args *aa_args = (struct adb_attach_args *)aux;

+ int error, kbd_done;

+ short cmd;

+ u_char buffer[9];

+#if NWSKBD > 0

+ struct wskbddev_attach_args a;

+ static int akbd_console_initted;

+ int wskbd_eligible;

+ wskbd_eligible = 1;

+#endif

+ sc->origaddr = aa_args->origaddr;

+ sc->adbaddr = aa_args->adbaddr;

+ sc->handler_id = aa_args->handler_id;

+ sc->sc_leds = (u_int8_t)0x00; /* initially off */

+ adbinfo.siServiceRtPtr = (Ptr)adb_kbd_asmcomplete;

+ adbinfo.siDataAreaAddr = (caddr_t)sc;

+ switch (sc->handler_id) {

+ case ADB_STDKBD:

+ printf("standard keyboard\n");

+ break;

+ case ADB_ISOKBD:

+ printf("standard keyboard (ISO layout)\n");

+ break;

+ case ADB_EXTKBD:

+ cmd = ADBTALK(sc->adbaddr, 1);

+ kbd_done =

+ (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd) == 0);

+ /* Ignore Logitech MouseMan/Trackman pseudo keyboard */

+ if (kbd_done && buffer[1] == 0x9a && buffer[2] == 0x20) {

+ printf("Mouseman (non-EMP) pseudo keyboard\n");

+ adbinfo.siServiceRtPtr = (Ptr)0;

+ adbinfo.siDataAreaAddr = (Ptr)0;

+#if NWSKBD > 0

+ wskbd_eligible = 0;

+#endif /* NWSKBD > 0 */

+ } else if (kbd_done && buffer[1] == 0x9a && buffer[2] == 0x21) {

+ printf("Trackman (non-EMP) pseudo keyboard\n");

+ adbinfo.siServiceRtPtr = (Ptr)0;

+ adbinfo.siDataAreaAddr = (Ptr)0;

+#if NWSKBD > 0

+ wskbd_eligible = 0;

+#endif /* NWSKBD > 0 */

+ } else {

+ printf("extended keyboard\n");

+#ifdef notyet

+ blinkleds(sc);

+#endif

+ }

+ break;

+ case ADB_EXTISOKBD:

+ printf("extended keyboard (ISO layout)\n");

+#ifdef notyet

+ blinkleds(sc);

+#endif

+ break;

+ case ADB_KBDII:

+ printf("keyboard II\n");

+ break;

+ case ADB_ISOKBDII:

+ printf("keyboard II (ISO layout)\n");

+ break;

+ case ADB_PBKBD:

+ printf("PowerBook keyboard\n");

+ break;

+ case ADB_PBISOKBD:

+ printf("PowerBook keyboard (ISO layout)\n");

+ break;

+ case ADB_ADJKPD:

+ printf("adjustable keypad\n");

+#if NWSKBD > 0

+ wskbd_eligible = 0;

+#endif /* NWSKBD > 0 */

+ break;

+ case ADB_ADJKBD:

+ printf("adjustable keyboard\n");

+ break;

+ case ADB_ADJISOKBD:

+ printf("adjustable keyboard (ISO layout)\n");

+ break;

+ case ADB_ADJJAPKBD:

+ printf("adjustable keyboard (Japanese layout)\n");

+ break;

+ case ADB_PBEXTISOKBD:

+ printf("PowerBook extended keyboard (ISO layout)\n");

+ break;

+ case ADB_PBEXTJAPKBD:

+ printf("PowerBook extended keyboard (Japanese layout)\n");

+ break;

+ case ADB_JPKBDII:

+ printf("keyboard II (Japanese layout)\n");

+ break;

+ case ADB_PBEXTKBD:

+ printf("PowerBook extended keyboard\n");

+ break;

+ case ADB_DESIGNKBD:

+ printf("extended keyboard\n");

+#ifdef notyet

+ blinkleds(sc);

+#endif

+ break;

+ case ADB_PBJPKBD:

+ printf("PowerBook keyboard (Japanese layout)\n");

+ break;

+ case ADB_PBG3JPKBD:

+ printf("PowerBook G3 keyboard (Japanese layout)\n");

+ break;

+ case ADB_PBG4KBD:

+ printf("PowerBook G4 keyboard (Inverted T)\n");

+ break;

+ case ADB_IBITISOKBD:

+ printf("iBook keyboard with inverted T (ISO layout)\n");

+ break;

+ default:

+ printf("mapped device (%d)\n", sc->handler_id);

+#if NWSKBD > 0

+ wskbd_eligible = 0;

+#endif /* NWSKBD > 0 */

+ break;

+ }

+ error = SetADBInfo(&adbinfo, sc->adbaddr);

+#ifdef ADB_DEBUG

+ if (adb_debug)

+ printf("akbd: returned %d from SetADBInfo\n", error);

+#endif

+#if NWSKBD > 0

+ if (akbd_is_console() && wskbd_eligible)

+ a.console = (++akbd_console_initted == 1);

+ else

+ a.console = 0;

+ a.keymap = &akbd_keymapdata;

+ a.accessops = &akbd_accessops;

+ a.accesscookie = sc;

+ sc->sc_wskbddev = config_found(self, &a, wskbddevprint);

+#endif

+/*

+ * Handle putting the keyboard data received from the ADB into

+ * an ADB event record.

+ */

+void

+kbd_adbcomplete(caddr_t buffer, caddr_t data_area, int adb_command)

+ adb_event_t event;

+ struct akbd_softc *ksc;

+ int adbaddr;

+#ifdef ADB_DEBUG

+ int i;

+ if (adb_debug)

+ printf("adb: transaction completion\n");

+#endif

+ adbaddr = ADB_CMDADDR(adb_command);

+ ksc = (struct akbd_softc *)data_area;

+ event.addr = adbaddr;

+ event.hand_id = ksc->handler_id;

+ event.def_addr = ksc->origaddr;

+ event.byte_count = buffer[0];

+ memcpy(event.bytes, buffer + 1, event.byte_count);

+#ifdef ADB_DEBUG

+ if (adb_debug) {

+ printf("akbd: from %d at %d (org %d) %d:", event.addr,

+ event.hand_id, event.def_addr, buffer[0]);

+ for (i = 1; i <= buffer[0]; i++)

+ printf(" %x", buffer[i]);

+ printf("\n");

+ }

+#endif

+ microtime(&event.timestamp);

+ kbd_processevent(&event, ksc);

+/*

+ * Given a keyboard ADB event, record the keycodes and call the key

+ * repeat handler, optionally passing the event through the mouse

+ * button emulation handler first.

+ */

+void

+kbd_processevent(adb_event_t *event, struct akbd_softc *ksc)

+ adb_event_t new_event;

+ new_event = *event;

+ new_event.u.k.key = event->bytes[0];

+ new_event.bytes[1] = 0xff;

+#if NWSKBD > 0

+ if (ksc->sc_wskbddev != NULL) /* wskbd is attached? */

+ akbd_intr(&new_event, ksc);

+#endif

+ if (event->bytes[1] != 0xff) {

+ new_event.u.k.key = event->bytes[1];

+ new_event.bytes[0] = event->bytes[1];

+ new_event.bytes[1] = 0xff;

+#if NWSKBD > 0

+ if (ksc->sc_wskbddev != NULL) /* wskbd is attached? */

+ akbd_intr(&new_event, ksc);

+#endif

+ }

+int

+akbd_enable(void *v, int on)

+ return 0;

+void

+akbd_set_leds(void *v, int on)

+int

+akbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)

+#ifdef WSDISPLAY_COMPAT_RAWKBD

+ struct akbd_softc *sc = v;

+#endif

+ switch (cmd) {

+ case WSKBDIO_GTYPE:

+ *(int *)data = WSKBD_TYPE_ADB;

+ return 0;

+ case WSKBDIO_SETLEDS:

+ return 0;

+ case WSKBDIO_GETLEDS:

+ *(int *)data = 0;

+ return 0;

+#ifdef WSDISPLAY_COMPAT_RAWKBD

+ case WSKBDIO_SETMODE:

+ sc->sc_rawkbd = *(int *)data == WSKBD_RAW;

+ timeout_del(&sc->sc_rawrepeat_ch);

+ return (0);

+#endif

+ case WSKBDIO_BELL:

+ case WSKBDIO_COMPLEXBELL:

+#define d ((struct wskbd_bell_data *)data)

+ mac68k_ring_bell(d->pitch, d->period * hz / 1000, 100);

+ /* comes in as msec, goes out as ticks; volume ignored */

+#undef d

+ return (0);

+ default:

+ return (-1);

+ }

+#ifdef WSDISPLAY_COMPAT_RAWKBD

+void

+akbd_rawrepeat(void *v)

+ struct akbd_softc *sc = v;

+ int s;

+ s = spltty();

+ wskbd_rawinput(sc->sc_wskbddev, sc->sc_rep, sc->sc_nrep);

+ splx(s);

+ timeout_add(&sc->sc_rawrepeat_ch, hz * REP_DELAYN / 1000);

+#endif

+int adb_polledkey;

+int

+akbd_intr(adb_event_t *event, struct akbd_softc *sc)

+ int key, press, val;

+ int type;

+ static int shift;

+ key = event->u.k.key;

+ /*

+ * Caps lock is weird. The key sequence generated is:

+ * press: down(57) [57] (LED turns on)

+ * release: up(127) [255]

+ * press: up(127) [255]

+ * release: up(57) [185] (LED turns off)

+ */

+ if (ADBK_KEYVAL(key) == ADBK_CAPSLOCK)

+ shift = 0;

+ if (key == 255) {

+ if (shift == 0) {

+ key = ADBK_KEYUP(ADBK_CAPSLOCK);

+ shift = 1;

+ } else {

+ key = ADBK_KEYDOWN(ADBK_CAPSLOCK);

+ shift = 0;

+ }

+ press = ADBK_PRESS(key);

+ val = ADBK_KEYVAL(key);

+ type = press ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP;

+ if (adb_polling) {

+ adb_polledkey = key;

+#ifdef WSDISPLAY_COMPAT_RAWKBD

+ } else if (sc->sc_rawkbd) {

+ char cbuf[MAXKEYS *2];

+ int c, j, s;

+ int npress;

+ j = npress = 0;

+ c = keyboard[val][3];

+ if (c == 0) {

+ return 0; /* XXX */

+ }

+ if (c & 0x80)

+ cbuf[j++] = 0xe0;

+ cbuf[j] = c & 0x7f;

+ if (type == WSCONS_EVENT_KEY_UP) {

+ cbuf[j] |= 0x80;

+ } else {

+ /* this only records last key pressed */

+ if (c & 0x80)

+ sc->sc_rep[npress++] = 0xe0;

+ sc->sc_rep[npress++] = c & 0x7f;

+ }

+ j++;

+ s = spltty();

+ wskbd_rawinput(sc->sc_wskbddev, cbuf, j);

+ splx(s);

+ timeout_del(&sc->sc_rawrepeat_ch);

+ sc->sc_nrep = npress;

+ if (npress != 0)

+ timeout_add(&sc->sc_rawrepeat_ch, hz * REP_DELAY1/1000);

+ return 0;

+#endif

+ } else {

+ wskbd_input(sc->sc_wskbddev, type, val);

+ }

+ return 0;

+int

+akbd_is_console(void)

+ extern struct mac68k_machine_S mac68k_machine;

+ return ((mac68k_machine.serial_console & 0x03) == 0);

+void akbd_cngetc(void *, u_int *, int *);

+void akbd_cnpollc(void *, int);

+struct wskbd_consops akbd_consops = {

+ akbd_cngetc,

+ akbd_cnpollc,

+};

+int

+akbd_cnattach(void)

+ extern struct wskbd_mapdata akbd_keymapdata;

+ wskbd_cnattach(&akbd_consops, NULL, &akbd_keymapdata);

+ return 0;

+void

+akbd_cngetc(void *v, u_int *type, int *data)

+ int intbits, key, press, val;

+ int s;

+ extern int adb_polledkey;

+ s = splhigh();

+ adb_polledkey = -1;

+ adb_polling = 1;

+ while (adb_polledkey == -1) {

+ intbits = via_reg(VIA1, vIFR);

+ if (intbits & V1IF_ADBRDY) {

+ mrg_adbintr();

+ via_reg(VIA1, vIFR) = V1IF_ADBRDY;

+ }

+ if (intbits & 0x10) {

+ mrg_pmintr();

+ via_reg(VIA1, vIFR) = 0x10;

+ }

+ adb_polling = 0;

+ splx(s);

+ key = adb_polledkey;

+ press = ADBK_PRESS(key);

+ val = ADBK_KEYVAL(key);

+ *data = val;

+ *type = press ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP;

+void

+akbd_cnpollc(void *v, int on)

diff --git a/sys/arch/mac68k/dev/akbdmap.h b/sys/arch/mac68k/dev/akbdmap.h
new file mode 100644
index 00000000000..8e0c01f0523
--- /dev/null
+++ b/sys/arch/mac68k/dev/akbdmap.h

@@ -0,0 +1,431 @@

+/* $NetBSD: akbdmap.h,v 1.7 2005/05/05 22:29:41 abs Exp $ */

+/*-

+ *

+ * This code is derived from software contributed to The NetBSD Foundation

+ * by Juergen Hannken-Illjes.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 1. Redistributions of source code must retain the above copyright

+ * notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above copyright

+ * notice, this list of conditions and the following disclaimer in the

+ * documentation and/or other materials provided with the distribution.

+ * 3. All advertising materials mentioning features or use of this software

+ * must display the following acknowledgement:

+ * This product includes software developed by the NetBSD

+ * Foundation, Inc. and its contributors.

+ * 4. Neither the name of The NetBSD Foundation nor the names of its

+ * contributors may be used to endorse or promote products derived

+ * from this software without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS

+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS

+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

+ * POSSIBILITY OF SUCH DAMAGE.

+ */

+/* XXX This list is incomplete. */

+#define KC(n) KS_KEYCODE(n)

+static const keysym_t akbd_keydesc_us[] = {

+/* pos command normal shifted */

+ KC(0), KS_a,

+ KC(1), KS_s,

+ KC(2), KS_d,

+ KC(3), KS_f,

+ KC(4), KS_h,

+ KC(5), KS_g,

+ KC(6), KS_z,

+ KC(7), KS_x,

+ KC(8), KS_c,

+ KC(9), KS_v,

+ KC(11), KS_b,

+ KC(12), KS_q,

+ KC(13), KS_w,

+ KC(14), KS_e,

+ KC(15), KS_r,

+ KC(16), KS_y,

+ KC(17), KS_t,

+ KC(18), KS_1, KS_exclam,

+ KC(19), KS_2, KS_at,

+ KC(20), KS_3, KS_numbersign,

+ KC(21), KS_4, KS_dollar,

+ KC(22), KS_6, KS_asciicircum,

+ KC(23), KS_5, KS_percent,

+ KC(24), KS_equal, KS_plus,

+ KC(25), KS_9, KS_parenleft,

+ KC(26), KS_7, KS_ampersand,

+ KC(27), KS_minus, KS_underscore,

+ KC(28), KS_8, KS_asterisk,

+ KC(29), KS_0, KS_parenright,

+ KC(30), KS_bracketright, KS_braceright,

+ KC(31), KS_o,

+ KC(32), KS_u,

+ KC(33), KS_bracketleft, KS_braceleft,

+ KC(34), KS_i,

+ KC(35), KS_p,

+ KC(36), KS_Return,

+ KC(37), KS_l,

+ KC(38), KS_j,

+ KC(39), KS_apostrophe, KS_quotedbl,

+ KC(40), KS_k,

+ KC(41), KS_semicolon, KS_colon,

+ KC(42), KS_backslash, KS_bar,

+ KC(43), KS_comma, KS_less,

+ KC(44), KS_slash, KS_question,

+ KC(45), KS_n,

+ KC(46), KS_m,

+ KC(47), KS_period, KS_greater,

+ KC(48), KS_Tab,

+ KC(49), KS_space,

+ KC(50), KS_grave, KS_asciitilde,

+ KC(51), KS_Delete,

+ KC(52), KS_KP_Enter, /* Pretend this is alt-R ? */

+ KC(53), KS_Escape,

+ KC(54), KS_Control_L,

+ KC(55), KS_Cmd, /* Command */

+ KC(56), KS_Shift_L,

+ KC(57), KS_Caps_Lock,

+ KC(58), KS_Cmd1, /* Option */

+ KC(59), KS_Left,

+ KC(60), KS_Right,

+ KC(61), KS_Down,

+ KC(62), KS_Up,

+ KC(65), KS_KP_Decimal,

+ KC(67), KS_KP_Multiply,

+ KC(69), KS_KP_Add,

+ KC(71), KS_Num_Lock,

+ KC(75), KS_KP_Divide,

+ KC(76), KS_KP_Enter,

+ KC(78), KS_KP_Subtract,

+ KC(81), KS_KP_Equal,

+ KC(82), KS_KP_Insert, KS_KP_0,

+ KC(83), KS_KP_End, KS_KP_1,

+ KC(84), KS_KP_Down, KS_KP_2,

+ KC(85), KS_KP_Next, KS_KP_3,

+ KC(86), KS_KP_Left, KS_KP_4,

+ KC(87), KS_KP_Begin, KS_KP_5,

+ KC(88), KS_KP_Right, KS_KP_6,

+ KC(89), KS_KP_Home, KS_KP_7,

+ KC(91), KS_KP_Up, KS_KP_8,

+ KC(92), KS_KP_Prior, KS_KP_9,

+ KC(95), KS_KP_Delete, KS_KP_Decimal,

+ KC(96), KS_f5,

+ KC(97), KS_f6,

+ KC(98), KS_f7,

+ KC(99), KS_f3,

+ KC(100), KS_f8,

+ KC(101), KS_f9,

+ KC(103), KS_f11,

+ KC(105), KS_Print_Screen,

+ KC(106), KS_KP_Enter,

+ KC(107), KS_Hold_Screen,

+ KC(109), KS_f10,

+ KC(111), KS_f12,

+ KC(113), KS_Pause,

+ KC(114), KS_Insert,

+ KC(115), KS_Home,

+ KC(116), KS_Prior,

+ KC(117), KS_Delete,

+ KC(118), KS_f4,

+ KC(119), KS_End,

+ KC(120), KS_f2,

+ KC(121), KS_Next,

+ KC(122), KS_f1,

+ KC(127), KS_Cmd_Debugger,

+};

+static const keysym_t akbd_keydesc_fr[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(0), KS_q,

+ KC(1), KS_s, KS_S, KS_Ograve,

+ KC(4), KS_h, KS_H, KS_Igrave, KS_Icircumflex,

+ KC(6), KS_w, KS_W, KS_less, KS_greater,

+ KC(8), KS_c, KS_C, KS_copyright, KS_cent,

+ KC(10), KS_at, KS_numbersign,

+ KC(11), KS_b, KS_B, KS_ssharp,

+ KC(12), KS_a, KS_A, KS_ae, KS_AE,

+ KC(13), KS_z, KS_Z, KS_Acircumflex, KS_Aring,

+ KC(14), KS_e, KS_E, KS_ecircumflex, KS_Ecircumflex,

+ KC(15), KS_r, KS_R, KS_registered, /* Euro */

+ KC(16), KS_y, KS_Y, KS_Uacute,

+ KC(18), KS_ampersand, KS_1, KS_voidSymbol, KS_dead_acute,

+ KC(19), KS_eacute, KS_2, KS_ediaeresis,

+ KC(20), KS_quotedbl, KS_3,

+ KC(21), KS_apostrophe, KS_4, KS_braceleft, KS_bracketleft,

+ KC(22), KS_section, KS_6, KS_paragraph,

+ KC(23), KS_parenleft, KS_5, KS_braceleft, KS_bracketleft,

+ KC(24), KS_minus, KS_underscore, KS_braceright,

+ KC(25), KS_ccedilla, KS_9, KS_Ccedilla, KS_Agrave,

+ KC(26), KS_egrave, KS_7, KS_guillemotleft,KS_guillemotright,

+ KC(27), KS_parenright, KS_degree, KS_braceright, KS_bracketright,

+ KC(28), KS_exclam, KS_8, KS_exclamdown, KS_Ucircumflex,

+ KC(29), KS_agrave, KS_0, KS_oslash,

+ KC(30), KS_dollar, KS_asterisk, KS_comma, KS_yen,

+ KC(33), KS_dead_circumflex, KS_dead_diaeresis,KS_ocircumflex,KS_Ocircumflex,

+ KC(34), KS_i, KS_I, KS_icircumflex, KS_Icircumflex,

+ KC(37), KS_l, KS_L, KS_notsign, KS_bar,

+ KC(38), KS_j, KS_J, KS_Idiaeresis, KS_Igrave,

+ KC(39), KS_ugrave, KS_percent, KS_Ugrave,

+ KC(40), KS_k, KS_K, KS_Egrave, KS_Ediaeresis,

+ KC(41), KS_m, KS_M, KS_mu, KS_Ograve,

+ KC(42), KS_dead_grave, KS_sterling, KS_at, KS_numbersign,

+ KC(43), KS_semicolon, KS_period,

+ KC(44), KS_equal, KS_plus, KS_voidSymbol, KS_plusminus,

+ KC(45), KS_n, KS_N, KS_dead_tilde,

+ KC(46), KS_comma, KS_question, KS_voidSymbol, KS_questiondown,

+ KC(47), KS_colon, KS_slash, KS_division, KS_backslash,

+ KC(50), KS_less, KS_greater,

+ KC(52), KS_Alt_R,

+ KC(55), KS_Meta_L, /* Command */

+ KC(58), KS_Mode_switch, KS_Multi_key, /* Option */

+};

+static const keysym_t akbd_keydesc_fr_nodead[] = {

+ KC(18), KS_ampersand, KS_1, KS_voidSymbol, KS_acute,

+ KC(33), KS_asciicircum, KS_diaeresis, KS_ocircumflex, KS_Ocircumflex,

+ KC(42), KS_grave, KS_sterling, KS_at, KS_numbersign,

+ KC(45), KS_n, KS_N, KS_asciitilde,

+};

+static const keysym_t akbd_keydesc_jp[] = {

+/* pos command normal shifted */

+ KC(19), KS_2, KS_quotedbl,

+ KC(22), KS_6, KS_ampersand,

+ KC(24), KS_asciicircum, KS_asciitilde,

+ KC(25), KS_9, KS_parenright,

+ KC(26), KS_7, KS_apostrophe,

+ KC(27), KS_minus, KS_equal,

+ KC(28), KS_8, KS_parenleft,

+ KC(29), KS_0,

+ KC(30), KS_bracketleft, KS_braceleft,

+ KC(33), KS_at, KS_grave,

+ KC(39), KS_colon, KS_asterisk,

+ KC(41), KS_semicolon, KS_plus,

+ KC(42), KS_bracketright,KS_braceright,

+ KC(93), KS_backslash, KS_bar,

+ KC(94), KS_underscore,

+};

+static const keysym_t akbd_keydesc_uk[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(10), KS_section, KS_plusminus,

+ KC(20), KS_3, KS_sterling, KS_numbersign,

+ KC(52), KS_KP_Enter,

+ KC(58), KS_Mode_switch, KS_Multi_key, /* Option */

+};

+static const keysym_t akbd_keydesc_sv[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(10), KS_section, KS_degree,

+ KC(19), KS_2, KS_quotedbl, KS_at,

+ KC(21), KS_4, KS_dollar,

+ KC(22), KS_6, KS_ampersand,

+ KC(24), KS_dead_acute, KS_dead_grave,

+ KC(25), KS_9, KS_parenright, KS_bracketright,

+ KC(26), KS_7, KS_slash, KS_braceleft,

+ KC(27), KS_plus, KS_question, KS_backslash,

+ KC(28), KS_8, KS_parenleft, KS_bracketleft,

+ KC(29), KS_0, KS_equal, KS_braceright,

+ KC(30), KS_dead_diaeresis,KS_dead_circumflex,KS_dead_tilde,

+ KC(33), KS_aring,

+ KC(39), KS_adiaeresis,

+ KC(41), KS_odiaeresis,

+ KC(42), KS_apostrophe, KS_asterisk,

+ KC(43), KS_comma, KS_semicolon,

+ KC(44), KS_minus, KS_underscore,

+ KC(47), KS_period, KS_colon,

+ KC(50), KS_less, KS_greater, KS_bar,

+ KC(58), KS_Mode_switch,KS_Multi_key,

+};

+static const keysym_t akbd_keydesc_sv_nodead[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(24), KS_apostrophe, KS_grave,

+ KC(30), KS_diaeresis, KS_asciicircum, KS_asciitilde,

+};

+static const keysym_t akbd_keydesc_de[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(0), KS_a, KS_A, KS_aring, KS_Aring,

+ KC(1), KS_s, KS_S, KS_voidSymbol, KS_Iacute,

+ KC(3), KS_f, KS_F, KS_voidSymbol, KS_Idiaeresis,

+ KC(4), KS_h, KS_H, KS_ordfeminine, KS_Oacute,

+ KC(5), KS_g, KS_G, KS_copyright, KS_Igrave,

+ KC(6), KS_y, KS_Y, KS_yen,

+ KC(7), KS_x, KS_X, KS_voidSymbol, KS_Ugrave,

+ KC(8), KS_c, KS_C, KS_ccedilla, KS_Ccedilla,

+ KC(10), KS_dead_circumflex,KS_degree,

+ KC(12), KS_q, KS_Q, KS_guillemotleft,KS_guillemotright,

+ KC(15), KS_r, KS_R, KS_registered, KS_cedilla,

+ KC(16), KS_z, KS_Z,

+ KC(18), KS_1, KS_exclam, KS_exclamdown, KS_notsign,

+ KC(19), KS_2, KS_quotedbl,

+ KC(20), KS_3, KS_section, KS_paragraph, KS_numbersign,

+ KC(21), KS_4, KS_dollar, KS_cent, KS_sterling,

+ KC(22), KS_6, KS_ampersand, KS_bracketright,KS_dead_circumflex,

+ KC(23), KS_5, KS_percent, KS_bracketleft,

+ KC(24), KS_dead_acute, KS_dead_grave, KS_apostrophe,

+ KC(25), KS_9, KS_parenright, KS_braceright, KS_periodcentered,

+ KC(26), KS_7, KS_slash, KS_bar, KS_backslash,

+ KC(27), KS_ssharp, KS_question, KS_questiondown,

+ KC(28), KS_8, KS_parenleft, KS_braceleft,

+ KC(29), KS_0, KS_equal, KS_voidSymbol, KS_macron,

+ KC(30), KS_plus, KS_asterisk, KS_plusminus,

+ KC(31), KS_o, KS_O, KS_oslash, KS_Ooblique,

+ KC(32), KS_u, KS_U, KS_dead_diaeresis,KS_Aacute,

+ KC(33), KS_udiaeresis, KS_Udiaeresis, KS_voidSymbol, KS_degree,

+ KC(34), KS_i, KS_I, KS_voidSymbol, KS_Ucircumflex,

+ KC(37), KS_l, KS_L, KS_at,

+ KC(38), KS_j, KS_J, KS_masculine,

+ KC(39), KS_adiaeresis, KS_Adiaeresis, KS_ae, KS_AE,

+ KC(41), KS_odiaeresis, KS_Odiaeresis,

+ KC(42), KS_numbersign, KS_apostrophe,

+ KC(43), KS_comma, KS_semicolon,

+ KC(44), KS_minus, KS_underscore,

+ KC(45), KS_n, KS_N, KS_dead_tilde,

+ KC(46), KS_m, KS_M, KS_mu,

+ KC(47), KS_period, KS_colon,

+ KC(50), KS_less, KS_greater,

+ KC(52), KS_Multi_key,

+ KC(58), KS_Mode_switch,

+};

+static const keysym_t akbd_keydesc_de_nodead[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(10), KS_asciicircum, KS_degree,

+ KC(22), KS_6, KS_ampersand, KS_bracketright,KS_asciicircum,

+ KC(24), KS_acute, KS_grave, KS_apostrophe,

+ KC(32), KS_u, KS_U, KS_diaeresis, KS_Aacute,

+ KC(45), KS_n, KS_N, KS_asciitilde,

+};

+static const keysym_t akbd_keydesc_sf[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(6), KS_y,

+ KC(10), KS_paragraph, KS_degree,

+ KC(16), KS_z,

+ KC(18), KS_plus, KS_1,

+ KC(19), KS_quotedbl, KS_2,

+ KC(20), KS_asterisk, KS_3,

+ KC(21), KS_ccedilla, KS_4, KS_Ccedilla,

+ KC(22), KS_ampersand, KS_6,

+ KC(23), KS_percent, KS_5,

+ KC(24), KS_dead_circumflex,KS_grave,

+ KC(25), KS_parenright, KS_9,

+ KC(26), KS_slash, KS_7,

+ KC(27), KS_apostrophe, KS_question,

+ KC(28), KS_parenleft, KS_8,

+ KC(29), KS_equal, KS_0,

+ KC(30), KS_dead_diaeresis,KS_exclam,

+ KC(33), KS_egrave, KS_udiaeresis,

+ KC(39), KS_agrave, KS_adiaeresis,

+ KC(41), KS_eacute, KS_odiaeresis,

+ KC(42), KS_dollar, KS_sterling,

+ KC(43), KS_period, KS_colon,

+ KC(46), KS_comma, KS_semicolon,

+ KC(47), KS_minus, KS_underscore,

+ KC(50), KS_less, KS_greater,

+};

+static const keysym_t akbd_keydesc_es[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(10), KS_degree, KS_ordfeminine, KS_backslash,

+ KC(18), KS_1, KS_exclam, KS_bar,

+ KC(19), KS_2, KS_quotedbl, KS_at,

+ KC(20), KS_3, KS_periodcentered, KS_numbersign,

+ KC(21), KS_4, KS_dollar, KS_asciitilde,

+ KC(22), KS_6, KS_ampersand, KS_notsign,

+ KC(23), KS_5, KS_percent,

+ KC(24), KS_exclamdown, KS_questiondown,

+ KC(25), KS_9, KS_parenright,

+ KC(26), KS_7, KS_slash,

+ KC(27), KS_apostrophe, KS_question,

+ KC(28), KS_8, KS_parenleft,

+ KC(29), KS_0, KS_equal,

+ KC(30), KS_plus, KS_asterisk, KS_bracketright,

+ KC(33), KS_dead_grave, KS_dead_circumflex, KS_bracketleft,

+ KC(39), KS_dead_acute, KS_dead_diaeresis, KS_braceleft,

+ KC(41), KS_ntilde,

+ KC(42), KS_ccedilla, KS_Ccedilla, KS_braceright,

+ KC(43), KS_comma, KS_semicolon,

+ KC(44), KS_minus, KS_underscore,

+ KC(47), KS_period, KS_colon,

+ KC(50), KS_less, KS_greater,

+ KC(55), KS_Alt_L, /* Command */

+ KC(58), KS_Mode_switch, KS_Multi_key, /* Option */

+};

+static const keysym_t akbd_keydesc_pt[] = {

+/* pos normal shifted altgr shift-altgr */

+ KC(7), KS_x, KS_X, KS_guillemotleft, KS_guillemotright,

+ KC(10), KS_section, KS_plusminus,

+ KC(19), KS_2, KS_quotedbl, KS_at,

+ KC(20), KS_3, KS_numbersign, KS_sterling,

+ KC(22), KS_6, KS_ampersand,

+ KC(24), KS_plus, KS_asterisk,

+ KC(25), KS_9, KS_parenright, KS_bracketright, KS_braceright,

+ KC(26), KS_7, KS_slash,

+ KC(27), KS_apostrophe, KS_question,

+ KC(28), KS_8, KS_parenleft, KS_bracketleft, KS_braceleft,

+ KC(29), KS_0, KS_equal,

+ KC(30), KS_dead_acute, KS_dead_grave,

+ KC(33), KS_masculine, KS_ordfeminine,

+ KC(39), KS_dead_tilde, KS_dead_circumflex,

+ KC(41), KS_ccedilla, KS_Ccedilla,

+ KC(43), KS_comma, KS_semicolon,

+ KC(44), KS_minus, KS_underscore,

+ KC(47), KS_period, KS_colon,

+ KC(50), KS_less, KS_greater,

+ KC(58), KS_Mode_switch,

+ KC(81), KS_KP_Equal,

+};

+#define KBD_MAP(name, base, map) \

+ { name, base, sizeof(map)/sizeof(keysym_t), map }

+static const struct wscons_keydesc akbd_keydesctab[] = {

+ KBD_MAP(KB_US, 0, akbd_keydesc_us),

+ KBD_MAP(KB_FR, KB_US, akbd_keydesc_fr),

+ KBD_MAP(KB_JP, KB_US, akbd_keydesc_jp),

+ KBD_MAP(KB_FR | KB_NODEAD, KB_FR, akbd_keydesc_fr_nodead),

+ KBD_MAP(KB_SF, KB_US, akbd_keydesc_sf),

+ KBD_MAP(KB_SV, KB_US, akbd_keydesc_sv),

+ KBD_MAP(KB_SV | KB_NODEAD, KB_SV, akbd_keydesc_sv_nodead),

+ KBD_MAP(KB_DE, KB_US, akbd_keydesc_de),

+ KBD_MAP(KB_DE | KB_NODEAD, KB_DE, akbd_keydesc_de_nodead),

+ KBD_MAP(KB_UK, KB_US, akbd_keydesc_uk),

+ KBD_MAP(KB_ES, KB_US, akbd_keydesc_es),

+ KBD_MAP(KB_PT, KB_US, akbd_keydesc_pt),

+ {0, 0, 0, 0}

+};

+#undef KBD_MAP

+#undef KC

diff --git a/sys/arch/mac68k/dev/akbdvar.h b/sys/arch/mac68k/dev/akbdvar.h
new file mode 100644
index 00000000000..9688e8b421c
--- /dev/null
+++ b/sys/arch/mac68k/dev/akbdvar.h

@@ -0,0 +1,71 @@

+/* $OpenBSD: akbdvar.h,v 1.1 2006/01/04 20:39:04 miod Exp $ */

+/* $NetBSD: akbdvar.h,v 1.4 1999/02/17 14:56:56 tsubai Exp $ */