src/devices/lk201.c

/*
 *  Copyright (C) 2003-2005  Anders Gavare.  All rights reserved.
 *
 *  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. 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 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 AUTHOR 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.
 *   
 *
 *  $Id: lk201.c,v 1.24 2005/02/13 11:40:58 debug Exp $
 *  
 *  LK201 keyboard and mouse specifics, used by the dc7085 and scc serial
 *  controller devices.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "console.h"
#include "devices.h"
#include "misc.h"

#include "dc7085.h"     /*  for port names  */
#include "lk201.h"


/*
 *  lk201_convert_ascii_to_keybcode():
 *
 *  Converts ascii console input to LK201 keyboard scan codes, and adds
 *  those scancodes using the add_to_rx_queue() function.
 */
void lk201_convert_ascii_to_keybcode(struct lk201_data *d, unsigned char ch)
{
        int i, found=-1, shifted = 0, controlled = 0;

        if (d->keyb_buf_pos > 0 && d->keyb_buf_pos < sizeof(d->keyb_buf)) {
                /*  Escape sequence:  */
                d->keyb_buf[d->keyb_buf_pos] = ch;
                d->keyb_buf_pos ++;

                if (d->keyb_buf_pos == 2) {
                        if (ch == '[')
                                return;
                        d->keyb_buf_pos = 0;
                        /*  not esc+[, output as normal key  */
                } else {
                        /*  Inside an esc+[ sequence  */

                        switch (ch) {
                        case 'A':  found = 0xaa;  /*  Up     */  break;
                        case 'B':  found = 0xa9;  /*  Down   */  break;
                        case 'C':  found = 0xa8;  /*  Right  */  break;
                        case 'D':  found = 0xa7;  /*  Left   */  break;
                        /*  TODO: pageup, pagedown, ...  */
                        default:
                                ;
                        }

                        d->keyb_buf_pos = 0;
                }
        } else
                d->keyb_buf_pos = 0;

        if (found == -1) {
                switch (ch) {
                case '\b':
                        found = 0xbc;
                        break;
                case '\n':
                case '\r':
                        found = 0xbd;
                        break;
                case '\t':
                        found = 0xbe;
                        break;
                case 27:        /*  esc  */
                        d->keyb_buf[0] = 27;
                        d->keyb_buf_pos = 1;
                        return;
                default:
                        if (ch >= 1 && ch <= 26) {
                                ch = 'a' + ch - 1;
                                controlled = 1;
                        }

                        shifted = 0;
                        for (i=0; i<256; i++) {
                                /*  Skip numeric digits, so that the normal
                                        digits are used instead.  */
                                if (i >= 0x92 && i<=0xa0)
                                        continue;

                                if (unshiftedAscii[i] == ch) {
                                        found = i;
                                        break;
                                }
                        }

                        if (found == -1) {
                                /*  unshift ch:  */
                                if (ch >= 'A' && ch <= 'Z')
                                        ch = ch + ('a' - 'A');
                                for (i=0; i<256; i++)
                                        if (shiftedAscii[i] == ch) {
                                                found = i;
                                                shifted = 1;
                                                break;
                                        }
                        }
                }
        }

        if (!shifted)
                d->add_to_rx_queue(d->add_data, KEY_UP, DCKBD_PORT);
        else {
                d->add_to_rx_queue(d->add_data, KEY_UP, DCKBD_PORT);
                d->add_to_rx_queue(d->add_data, KEY_SHIFT, DCKBD_PORT);
        }

        if (controlled)
                d->add_to_rx_queue(d->add_data, KEY_CONTROL, DCKBD_PORT);

        /*  Send the actual scan code:  */
        d->add_to_rx_queue(d->add_data, found, DCKBD_PORT);

        /*  Release the key:  */
        d->add_to_rx_queue(d->add_data, KEY_UP, DCKBD_PORT);
}


/*
 *  lk201_send_mouse_update_sequence():
 *
 *  mouse_x,y,buttons contains the coordinates on the host's display, the
 *  "goal" of where we want to move. d->mouse_* contains the current state.
 *
 *  TODO:  Comment this better.
 */
void lk201_send_mouse_update_sequence(struct lk201_data *d, int mouse_x,
        int mouse_y, int mouse_buttons, int mouse_fb_nr)
{
        int xsign, xdelta, ysign, ydelta, m;
        int framebuffer_nr;

        if (d->old_host_mouse_x == mouse_x &&
            d->old_host_mouse_y == mouse_y)
                d->old_host_mouse_stays_put ++;
        else
                d->old_host_mouse_stays_put = 0;

        d->old_host_mouse_x = mouse_x;
        d->old_host_mouse_y = mouse_y;

        if (d->old_host_mouse_stays_put > 400 &&
            d->mouse_buttons == mouse_buttons)
                return;

        console_get_framebuffer_mouse(&d->mouse_x, &d->mouse_y,
            &framebuffer_nr);

        xdelta = mouse_x - d->mouse_x;
        ydelta = mouse_y - d->mouse_y;

        /*
         *  If the last framebuffer cursor placement was not in the
         *  same window as the last host cursor movement, then we
         *  we have to move to the leftmost extreme or rightmost
         *  extreme:
         */
        if (framebuffer_nr != mouse_fb_nr) {
                if (mouse_fb_nr > framebuffer_nr)
                        xdelta = 2000;
                if (mouse_fb_nr < framebuffer_nr)
                        xdelta = -2000;
        }

        /*  If no change, then don't send any update!  */
        if (xdelta == 0 && ydelta == 0 && d->mouse_buttons == mouse_buttons)
                return;

        m = 4 >> (d->old_host_mouse_stays_put / 30);
        if (m < 1)
                m = 1;

        if (xdelta > m)
                xdelta = m;
        if (xdelta < -m)
                xdelta = -m;
        if (ydelta > m)
                ydelta = m;
        if (ydelta < -m)
                ydelta = -m;

        xsign = xdelta < 0? 1 : 0;
        ysign = ydelta < 0? 1 : 0;

        d->mouse_x += xdelta;
        d->mouse_y += ydelta;
        d->mouse_buttons = mouse_buttons;

        switch (d->mouse_mode) {
        case 0:
                /*  Do nothing (before the mouse is initialized)  */
                break;
        case MOUSE_INCREMENTAL:
                if (xdelta < 0)
                        xdelta = -xdelta;
                if (ydelta < 0)
                        ydelta = -ydelta;

                /*  Reverse sign of x:  (this is needed for some reason)  */
                xsign ^= 1;

                d->add_to_rx_queue(d->add_data, MOUSE_START_FRAME +
                    MOUSE_X_SIGN*xsign + MOUSE_Y_SIGN*ysign +
                    (mouse_buttons & 7), DCMOUSE_PORT);
                d->add_to_rx_queue(d->add_data, xdelta, DCMOUSE_PORT);
                d->add_to_rx_queue(d->add_data, ydelta, DCMOUSE_PORT);
                break;
        default:
                /*  TODO:  prompt mode and perhaps more stuff  */
                fatal("[ lk201: mouse mode 0x%02x unknown: TODO ]\n",
                    d->mouse_mode);
        }
}


/*
 *  lk201_tick():
 *
 *  This function should be called "every now and then".
 *  If a key is available from the keyboard, add it to the rx queue.
 *  If other bits are set, an interrupt might need to be caused.
 */
void lk201_tick(struct lk201_data *d)
{
        int mouse_x, mouse_y, mouse_buttons, mouse_fb_nr;

        if (console_charavail(d->console_handle)) {
                unsigned char ch = console_readchar(d->console_handle);
                if (d->use_fb)
                        lk201_convert_ascii_to_keybcode(d, ch);
                else {
                        /*
                         *  This is ugly, but necessary because different
                         *  machines seem to use different ports for their
                         *  serial console:
                         *
                         *  DEC MIPSMATE 5100 uses the keyboard port.
                         *  DECstation 3100 (PMAX) uses the printer port.
                         *  All others seem to use the comm port.
                         */
                        d->add_to_rx_queue(d->add_data, ch, DCKBD_PORT);
                        d->add_to_rx_queue(d->add_data, ch, DCCOMM_PORT);
                        d->add_to_rx_queue(d->add_data, ch, DCPRINTER_PORT);
                }
        }

        /*  Don't do mouse updates if we're running in serial console mode:  */
        if (!d->use_fb)
                return;

        d->mouse_check_interval --;
        if (d->mouse_check_interval <= 0) {
                d->mouse_check_interval =
                    d->mouse_check_interval_reset;

                /*
                 *  Check for mouse updates:
                 *
                 *  Note:  mouse_{x,y} are where the mouse is
                 *  on the host's display.
                 */
                console_getmouse(&mouse_x, &mouse_y, &mouse_buttons,
                    &mouse_fb_nr);

                if (mouse_x != d->mouse_x || mouse_y != d->mouse_y ||
                    mouse_buttons != d->mouse_buttons)
                        lk201_send_mouse_update_sequence(d, mouse_x, mouse_y,
                            mouse_buttons, mouse_fb_nr);
        }
}


void lk201_tx_data(struct lk201_data *d, int port, int idata)
{
        switch (port) {
        case DCKBD_PORT:                /*  port 0  */
                if (!d->use_fb) {
                        /*  Simply print the character to stdout:  */
                        console_putchar(d->console_handle, idata);
                } else {
                        switch (idata) {
                        case LK_LED_DISABLE:    /*  0x11  */
                                break;
                        case LK_LED_ENABLE:     /*  0x13  */
                                break;
                        case LK_BELL_ENABLE:    /*  0x23  */
                                break;
                        case LED_1:
                        case LED_2:
                                break;
                        case LED_3:
                                break;
                        case LED_4:
                                break;
                        case LK_KBD_ENABLE:     /*  0x8b  */
                                break;
                        case LED_ALL:           /*  0x8f  */
                                break;
                        case LK_RING_BELL:      /*  0xa7  */
                                break;
                        case 0xab:      /*  Get Keyboard ID:  */
                                /*
                                 *  First byte:
                                 *      1 = LK201
                                 *      2 = LK401
                                 *      3 = LK443
                                 *      4 = LK421
                                 *
                                 *  TODO: What about the second byte?
                                 */
                                d->add_to_rx_queue(d->add_data,
                                    0x01, DCKBD_PORT);
                                d->add_to_rx_queue(d->add_data,
                                    0x22, DCKBD_PORT);
                                break;
                        case LK_DEFAULTS:       /*  0xd3  */
                                /*  TODO?  */
                                break;
                        case 0xfd:      /*  Keyboard self-test:  */
                                /*  Suitable return values according to
                                    Mach/PMAX source code:  */
                                d->add_to_rx_queue(d->add_data,
                                    0x01, DCKBD_PORT);
                                d->add_to_rx_queue(d->add_data,
                                    0x00, DCKBD_PORT);
                                d->add_to_rx_queue(d->add_data,
                                    0x00, DCKBD_PORT);
                                d->add_to_rx_queue(d->add_data,
                                    0x00, DCKBD_PORT);
                                break;
                        default:
                                debug("[ lk201: keyboard control: 0x%x ]\n",
                                    idata);
                        }
                }
                break;
        case DCMOUSE_PORT:              /*  port 1  */
                debug("[ lk201: writing data to MOUSE: 0x%x", idata);
                if (idata == MOUSE_INCREMENTAL) {
                        d->mouse_mode = MOUSE_INCREMENTAL;
                } else if (idata == MOUSE_SELF_TEST) {
                        /*
                         *  Mouse self-test:
                         *
                         *  TODO: Find out if this is correct. The lowest
                         *        four bits of the second byte should be
                         *        0x2, according to NetBSD/pmax. But the
                         *        other bits and bytes?
                         */
                        debug(" (mouse self-test request)");
                        d->add_to_rx_queue(d->add_data,
                            0xa0 | d->mouse_revision, DCMOUSE_PORT);
                        d->add_to_rx_queue(d->add_data, 0x02, DCMOUSE_PORT);
                        d->add_to_rx_queue(d->add_data, 0x00, DCMOUSE_PORT);
                        d->add_to_rx_queue(d->add_data, 0x00, DCMOUSE_PORT);
                } else
                        debug(" UNKNOWN byte; TODO");
                debug(" ]\n");
                break;
        case DCCOMM_PORT:               /*  port 2  */
        case DCPRINTER_PORT:            /*  port 3  */
                /*  Simply print the character to stdout:  */
                console_putchar(d->console_handle, idata);
        }
}


/*
 *  lk201_init():
 *
 *  Initialize lk201 keyboard/mouse settings.
 */
void lk201_init(struct lk201_data *d, int use_fb,
        void (*add_to_rx_queue)(void *,int,int),
        int console_handle, void *add_data)
{
        memset(d, 0, sizeof(struct lk201_data));

        d->add_to_rx_queue = add_to_rx_queue;
        d->add_data = add_data;

        d->use_fb = use_fb;
        d->mouse_mode = 0;
        d->mouse_revision = 0;  /*  0..15  */
        d->console_handle = console_handle;

        d->mouse_check_interval_reset = 1 << 3;
}

1	dpavlin	4	/*
2			* Copyright (C) 2003-2005 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28			* $Id: lk201.c,v 1.24 2005/02/13 11:40:58 debug Exp $
29			*
30			* LK201 keyboard and mouse specifics, used by the dc7085 and scc serial
31			* controller devices.
32			*/
33
34			#include <stdio.h>
35			#include <stdlib.h>
36			#include <string.h>
37
38			#include "console.h"
39			#include "devices.h"
40			#include "misc.h"
41
42			#include "dc7085.h" /* for port names */
43			#include "lk201.h"
44
45
46			/*
47			* lk201_convert_ascii_to_keybcode():
48			*
49			* Converts ascii console input to LK201 keyboard scan codes, and adds
50			* those scancodes using the add_to_rx_queue() function.
51			*/
52			void lk201_convert_ascii_to_keybcode(struct lk201_data *d, unsigned char ch)
53			{
54			int i, found=-1, shifted = 0, controlled = 0;
55
56			if (d->keyb_buf_pos > 0 && d->keyb_buf_pos < sizeof(d->keyb_buf)) {
57			/* Escape sequence: */
58			d->keyb_buf[d->keyb_buf_pos] = ch;
59			d->keyb_buf_pos ++;
60
61			if (d->keyb_buf_pos == 2) {
62			if (ch == '[')
63			return;
64			d->keyb_buf_pos = 0;
65			/* not esc+[, output as normal key */
66			} else {
67			/* Inside an esc+[ sequence */
68
69			switch (ch) {
70			case 'A': found = 0xaa; /* Up */ break;
71			case 'B': found = 0xa9; /* Down */ break;
72			case 'C': found = 0xa8; /* Right */ break;
73			case 'D': found = 0xa7; /* Left */ break;
74			/* TODO: pageup, pagedown, ... */
75			default:
76			;
77			}
78
79			d->keyb_buf_pos = 0;
80			}
81			} else
82			d->keyb_buf_pos = 0;
83
84			if (found == -1) {
85			switch (ch) {
86			case '\b':
87			found = 0xbc;
88			break;
89			case '\n':
90			case '\r':
91			found = 0xbd;
92			break;
93			case '\t':
94			found = 0xbe;
95			break;
96			case 27: /* esc */
97			d->keyb_buf[0] = 27;
98			d->keyb_buf_pos = 1;
99			return;
100			default:
101			if (ch >= 1 && ch <= 26) {
102			ch = 'a' + ch - 1;
103			controlled = 1;
104			}
105
106			shifted = 0;
107			for (i=0; i<256; i++) {
108			/* Skip numeric digits, so that the normal
109			digits are used instead. */
110			if (i >= 0x92 && i<=0xa0)
111			continue;
112
113			if (unshiftedAscii[i] == ch) {
114			found = i;
115			break;
116			}
117			}
118
119			if (found == -1) {
120			/* unshift ch: */
121			if (ch >= 'A' && ch <= 'Z')
122			ch = ch + ('a' - 'A');
123			for (i=0; i<256; i++)
124			if (shiftedAscii[i] == ch) {
125			found = i;
126			shifted = 1;
127			break;
128			}
129			}
130			}
131			}
132
133			if (!shifted)
134			d->add_to_rx_queue(d->add_data, KEY_UP, DCKBD_PORT);
135			else {
136			d->add_to_rx_queue(d->add_data, KEY_UP, DCKBD_PORT);
137			d->add_to_rx_queue(d->add_data, KEY_SHIFT, DCKBD_PORT);
138			}
139
140			if (controlled)
141			d->add_to_rx_queue(d->add_data, KEY_CONTROL, DCKBD_PORT);
142
143			/* Send the actual scan code: */
144			d->add_to_rx_queue(d->add_data, found, DCKBD_PORT);
145
146			/* Release the key: */
147			d->add_to_rx_queue(d->add_data, KEY_UP, DCKBD_PORT);
148			}
149
150
151			/*
152			* lk201_send_mouse_update_sequence():
153			*
154			* mouse_x,y,buttons contains the coordinates on the host's display, the
155			* "goal" of where we want to move. d->mouse_* contains the current state.
156			*
157			* TODO: Comment this better.
158			*/
159			void lk201_send_mouse_update_sequence(struct lk201_data *d, int mouse_x,
160			int mouse_y, int mouse_buttons, int mouse_fb_nr)
161			{
162			int xsign, xdelta, ysign, ydelta, m;
163			int framebuffer_nr;
164
165			if (d->old_host_mouse_x == mouse_x &&
166			d->old_host_mouse_y == mouse_y)
167			d->old_host_mouse_stays_put ++;
168			else
169			d->old_host_mouse_stays_put = 0;
170
171			d->old_host_mouse_x = mouse_x;
172			d->old_host_mouse_y = mouse_y;
173
174			if (d->old_host_mouse_stays_put > 400 &&
175			d->mouse_buttons == mouse_buttons)
176			return;
177
178			console_get_framebuffer_mouse(&d->mouse_x, &d->mouse_y,
179			&framebuffer_nr);
180
181			xdelta = mouse_x - d->mouse_x;
182			ydelta = mouse_y - d->mouse_y;
183
184			/*
185			* If the last framebuffer cursor placement was not in the
186			* same window as the last host cursor movement, then we
187			* we have to move to the leftmost extreme or rightmost
188			* extreme:
189			*/
190			if (framebuffer_nr != mouse_fb_nr) {
191			if (mouse_fb_nr > framebuffer_nr)
192			xdelta = 2000;
193			if (mouse_fb_nr < framebuffer_nr)
194			xdelta = -2000;
195			}
196
197			/* If no change, then don't send any update! */
198			if (xdelta == 0 && ydelta == 0 && d->mouse_buttons == mouse_buttons)
199			return;
200
201			m = 4 >> (d->old_host_mouse_stays_put / 30);
202			if (m < 1)
203			m = 1;
204
205			if (xdelta > m)
206			xdelta = m;
207			if (xdelta < -m)
208			xdelta = -m;
209			if (ydelta > m)
210			ydelta = m;
211			if (ydelta < -m)
212			ydelta = -m;
213
214			xsign = xdelta < 0? 1 : 0;
215			ysign = ydelta < 0? 1 : 0;
216
217			d->mouse_x += xdelta;
218			d->mouse_y += ydelta;
219			d->mouse_buttons = mouse_buttons;
220
221			switch (d->mouse_mode) {
222			case 0:
223			/* Do nothing (before the mouse is initialized) */
224			break;
225			case MOUSE_INCREMENTAL:
226			if (xdelta < 0)
227			xdelta = -xdelta;
228			if (ydelta < 0)
229			ydelta = -ydelta;
230
231			/* Reverse sign of x: (this is needed for some reason) */
232			xsign ^= 1;
233
234			d->add_to_rx_queue(d->add_data, MOUSE_START_FRAME +
235			MOUSE_X_SIGNxsign + MOUSE_Y_SIGNysign +
236			(mouse_buttons & 7), DCMOUSE_PORT);
237			d->add_to_rx_queue(d->add_data, xdelta, DCMOUSE_PORT);
238			d->add_to_rx_queue(d->add_data, ydelta, DCMOUSE_PORT);
239			break;
240			default:
241			/* TODO: prompt mode and perhaps more stuff */
242			fatal("[ lk201: mouse mode 0x%02x unknown: TODO ]\n",
243			d->mouse_mode);
244			}
245			}
246
247
248			/*
249			* lk201_tick():
250			*
251			* This function should be called "every now and then".
252			* If a key is available from the keyboard, add it to the rx queue.
253			* If other bits are set, an interrupt might need to be caused.
254			*/
255			void lk201_tick(struct lk201_data *d)
256			{
257			int mouse_x, mouse_y, mouse_buttons, mouse_fb_nr;
258
259			if (console_charavail(d->console_handle)) {
260			unsigned char ch = console_readchar(d->console_handle);
261			if (d->use_fb)
262			lk201_convert_ascii_to_keybcode(d, ch);
263			else {
264			/*
265			* This is ugly, but necessary because different
266			* machines seem to use different ports for their
267			* serial console:
268			*
269			* DEC MIPSMATE 5100 uses the keyboard port.
270			* DECstation 3100 (PMAX) uses the printer port.
271			* All others seem to use the comm port.
272			*/
273			d->add_to_rx_queue(d->add_data, ch, DCKBD_PORT);
274			d->add_to_rx_queue(d->add_data, ch, DCCOMM_PORT);
275			d->add_to_rx_queue(d->add_data, ch, DCPRINTER_PORT);
276			}
277			}
278
279			/* Don't do mouse updates if we're running in serial console mode: */
280			if (!d->use_fb)
281			return;
282
283			d->mouse_check_interval --;
284			if (d->mouse_check_interval <= 0) {
285			d->mouse_check_interval =
286			d->mouse_check_interval_reset;
287
288			/*
289			* Check for mouse updates:
290			*
291			* Note: mouse_{x,y} are where the mouse is
292			* on the host's display.
293			*/
294			console_getmouse(&mouse_x, &mouse_y, &mouse_buttons,
295			&mouse_fb_nr);
296
297			if (mouse_x != d->mouse_x \|\| mouse_y != d->mouse_y \|\|
298			mouse_buttons != d->mouse_buttons)
299			lk201_send_mouse_update_sequence(d, mouse_x, mouse_y,
300			mouse_buttons, mouse_fb_nr);
301			}
302			}
303
304
305			void lk201_tx_data(struct lk201_data *d, int port, int idata)
306			{
307			switch (port) {
308			case DCKBD_PORT: /* port 0 */
309			if (!d->use_fb) {
310			/* Simply print the character to stdout: */
311			console_putchar(d->console_handle, idata);
312			} else {
313			switch (idata) {
314			case LK_LED_DISABLE: /* 0x11 */
315			break;
316			case LK_LED_ENABLE: /* 0x13 */
317			break;
318			case LK_BELL_ENABLE: /* 0x23 */
319			break;
320			case LED_1:
321			case LED_2:
322			break;
323			case LED_3:
324			break;
325			case LED_4:
326			break;
327			case LK_KBD_ENABLE: /* 0x8b */
328			break;
329			case LED_ALL: /* 0x8f */
330			break;
331			case LK_RING_BELL: /* 0xa7 */
332			break;
333			case 0xab: /* Get Keyboard ID: */
334			/*
335			* First byte:
336			* 1 = LK201
337			* 2 = LK401
338			* 3 = LK443
339			* 4 = LK421
340			*
341			* TODO: What about the second byte?
342			*/
343			d->add_to_rx_queue(d->add_data,
344			0x01, DCKBD_PORT);
345			d->add_to_rx_queue(d->add_data,
346			0x22, DCKBD_PORT);
347			break;
348			case LK_DEFAULTS: /* 0xd3 */
349			/* TODO? */
350			break;
351			case 0xfd: /* Keyboard self-test: */
352			/* Suitable return values according to
353			Mach/PMAX source code: */
354			d->add_to_rx_queue(d->add_data,
355			0x01, DCKBD_PORT);
356			d->add_to_rx_queue(d->add_data,
357			0x00, DCKBD_PORT);
358			d->add_to_rx_queue(d->add_data,
359			0x00, DCKBD_PORT);
360			d->add_to_rx_queue(d->add_data,
361			0x00, DCKBD_PORT);
362			break;
363			default:
364			debug("[ lk201: keyboard control: 0x%x ]\n",
365			idata);
366			}
367			}
368			break;
369			case DCMOUSE_PORT: /* port 1 */
370			debug("[ lk201: writing data to MOUSE: 0x%x", idata);
371			if (idata == MOUSE_INCREMENTAL) {
372			d->mouse_mode = MOUSE_INCREMENTAL;
373			} else if (idata == MOUSE_SELF_TEST) {
374			/*
375			* Mouse self-test:
376			*
377			* TODO: Find out if this is correct. The lowest
378			* four bits of the second byte should be
379			* 0x2, according to NetBSD/pmax. But the
380			* other bits and bytes?
381			*/
382			debug(" (mouse self-test request)");
383			d->add_to_rx_queue(d->add_data,
384			0xa0 \| d->mouse_revision, DCMOUSE_PORT);
385			d->add_to_rx_queue(d->add_data, 0x02, DCMOUSE_PORT);
386			d->add_to_rx_queue(d->add_data, 0x00, DCMOUSE_PORT);
387			d->add_to_rx_queue(d->add_data, 0x00, DCMOUSE_PORT);
388			} else
389			debug(" UNKNOWN byte; TODO");
390			debug(" ]\n");
391			break;
392			case DCCOMM_PORT: /* port 2 */
393			case DCPRINTER_PORT: /* port 3 */
394			/* Simply print the character to stdout: */
395			console_putchar(d->console_handle, idata);
396			}
397			}
398
399
400			/*
401			* lk201_init():
402			*
403			* Initialize lk201 keyboard/mouse settings.
404			*/
405			void lk201_init(struct lk201_data *d, int use_fb,
406			void (add_to_rx_queue)(void ,int,int),
407			int console_handle, void *add_data)
408			{
409			memset(d, 0, sizeof(struct lk201_data));
410
411			d->add_to_rx_queue = add_to_rx_queue;
412			d->add_data = add_data;
413
414			d->use_fb = use_fb;
415			d->mouse_mode = 0;
416			d->mouse_revision = 0; /* 0..15 */
417			d->console_handle = console_handle;
418
419			d->mouse_check_interval_reset = 1 << 3;
420			}
421