![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dtop_hdw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / chips|
Return to dtop_hdw.c CVS log | Up to [GnuMach] / Gnu-Mach / chips |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1993,1992 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * File: dtop_hdw.c
28: * Author: Alessandro Forin, Carnegie Mellon University
29: * Date: 1/92
30: *
31: * Hardware-level operations for the Desktop serial line
32: * bus (i2c aka ACCESS).
33: */
34:
35: #include <dtop.h>
36: #if NDTOP > 0
37: #include <bm.h>
38: #include <platforms.h>
39:
40: #include <machine/machspl.h> /* spl definitions */
41: #include <mach/std_types.h>
42: #include <device/io_req.h>
43: #include <device/tty.h>
44:
45: #include <chips/busses.h>
46: #include <chips/serial_defs.h>
47: #include <chips/screen_defs.h>
48: #include <chips/lk201.h>
49: #include <mips/PMAX/tc.h>
50:
51: #include <chips/dtop.h>
52:
53: #define DTOP_MAX_POLL 0x7fff /* about half a sec */
54:
55: #ifdef MAXINE
56:
57: typedef volatile unsigned int *data_reg_t; /* uC */
58: #define DTOP_GET_BYTE(data) (((*(data)) >> 8) & 0xff)
59: #define DTOP_PUT_BYTE(data,c) { *(data) = (c) << 8; }
60:
61: typedef volatile unsigned int *poll_reg_t; /* SIR */
62: #define DTOP_RX_AVAIL(poll) (*(poll) & 1)
63: #define DTOP_TX_AVAIL(poll) (*(poll) & 2)
64:
65: #else
66:
67: define how to get/put DTOP packets on this box
68:
69: #endif
70:
71: /*
72: * Driver status
73: */
74:
75: struct dtop_softc {
76: data_reg_t data;
77: poll_reg_t poll;
78: char polling_mode;
79: char probed_once;
80: short bad_pkts;
81:
82: struct dtop_ds {
83: int (*handler)(dtop_device_t,
84: dtop_message_t,
85: int,
86: unsigned char);
87: dtop_device status;
88: } device[(DTOP_ADDR_DEFAULT - DTOP_ADDR_FIRST) >> 1];
89:
90: # define DTOP_DEVICE_NO(address) (((address)-DTOP_ADDR_FIRST)>>1)
91:
92: } dtop_softc_data[NDTOP];
93:
94: typedef struct dtop_softc *dtop_softc_t;
95:
96: dtop_softc_t dtop_softc[NDTOP];
97:
98: /*
99: * Definition of the driver for the auto-configuration program.
100: */
101:
102: int dtop_probe(), dtop_intr();
103: static void dtop_attach();
104:
105: vm_offset_t dtop_std[NDTOP] = { 0 };
106: struct bus_device *dtop_info[NDTOP];
107: struct bus_driver dtop_driver =
108: { dtop_probe, 0, dtop_attach, 0, dtop_std, "dtop", dtop_info,};
109:
110:
111: int dtop_print_debug = 0;
112:
113: /*
114: * Adapt/Probe/Attach functions
115: */
116:
117: set_dtop_address( dtopunit, poll_reg)
118: data_reg_t poll_reg;
119: {
120: int i;
121:
122: extern int dtop_probe(), dtop_param(), dtop_start(),
123: dtop_putc(), dtop_getc(),
124: dtop_pollc(), dtop_mctl(), dtop_softCAR();
125:
126: dtop_std[dtopunit] = (vm_offset_t)poll_reg;
127:
128: /* Do this here */
129: console_probe = dtop_probe;
130: console_param = dtop_param;
131: console_start = dtop_start;
132: console_putc = dtop_putc;
133: console_getc = dtop_getc;
134: console_pollc = dtop_pollc;
135: console_mctl = dtop_mctl;
136: console_softCAR = dtop_softCAR;
137:
138: }
139:
140: dtop_probe( data_reg, ui)
141: data_reg_t data_reg;
142: struct bus_device *ui;
143: {
144: int dtopunit = ui->unit, i;
145: dtop_softc_t dtop;
146:
147: dtop = &dtop_softc_data[dtopunit];
148: dtop_softc[dtopunit] = dtop;
149:
150: dtop->poll = (poll_reg_t)dtop_std[dtopunit];
151: dtop->data = data_reg;
152:
153: for (i = 0; i < DTOP_MAX_DEVICES; i++)
154: dtop->device[i].handler = dtop_null_device_handler;
155:
156: /* a lot more needed here, fornow: */
157: dtop->device[DTOP_DEVICE_NO(0x6a)].handler = dtop_locator_handler;
158: dtop->device[DTOP_DEVICE_NO(0x6a)].status.locator.type =
159: DEV_MOUSE;
160: dtop->device[DTOP_DEVICE_NO(0x6a)].status.locator.relative =
161: 1;
162: dtop->device[DTOP_DEVICE_NO(0x6a)].status.locator.button_code[0] =
163: KEY_LEFT_BUTTON;
164: dtop->device[DTOP_DEVICE_NO(0x6a)].status.locator.button_code[1] =
165: KEY_RIGHT_BUTTON;
166: dtop->device[DTOP_DEVICE_NO(0x6a)].status.locator.button_code[2] =
167: KEY_MIDDLE_BUTTON;
168: dtop->device[DTOP_DEVICE_NO(0x6a)].status.locator.n_coords =
169: 2;
170:
171: dtop->device[DTOP_DEVICE_NO(0x6c)].handler = dtop_keyboard_handler;
172: dtop->device[DTOP_DEVICE_NO(0x6c)].status.keyboard.poll_frequency =
173: (hz * 5) / 100; /* x0.01 secs */
174: dtop->device[DTOP_DEVICE_NO(0x6c)].status.keyboard.bell_volume =
175: DTOP_CLICK_VOLUME_MAX;
176:
177: return 1;
178: }
179:
180: static void
181: dtop_attach(ui)
182: struct bus_device *ui;
183: {
184: int i;
185:
186: /* Initialize all the console ttys */
187: for (i = 0; i < 4; i++)
188: ttychars(console_tty[i]);
189: /* Mark keyboard and mouse present */
190: for (i = 0; i < 2; i++)
191: console_tty[i]->t_addr = (char*)1;
192: }
193:
194: /*
195: * Polled I/O (debugger)
196: */
197: dtop_pollc(unit, on)
198: boolean_t on;
199: {
200: dtop_softc_t dtop;
201:
202: dtop = dtop_softc[unit];
203: if (on) {
204: dtop->polling_mode++;
205: #if NBM > 0
206: screen_on_off(unit, TRUE);
207: #endif NBM > 0
208: } else
209: dtop->polling_mode--;
210: }
211:
212: /*
213: * Interrupt routine
214: */
215: dtop_intr (unit, spllevel, recvd)
216: spl_t spllevel;
217: boolean_t recvd;
218: {
219:
220: if (recvd) {
221: dtop_message msg;
222: int devno;
223: dtop_softc_t dtop;
224:
225: ssaver_bump(unit);
226:
227: #ifdef mips
228: splx(spllevel);
229: #endif
230:
231: dtop = dtop_softc[unit];
232: if (dtop_get_packet(dtop, &msg) < 0) {
233: if (dtop_print_debug)
234: printf("%s", "dtop: overrun (or stray)\n");
235: return;
236: }
237:
238: devno = DTOP_DEVICE_NO(msg.src_address);
239: if (devno < 0 || devno > 15) return; /* sanity */
240:
241: (void) (*dtop->device[devno].handler)
242: (&dtop->device[devno].status, &msg,
243: DTOP_EVENT_RECEIVE_PACKET, 0);
244:
245: } else {
246: /* fornow xmit is not intr based */
247: (*tc_enable_interrupt)( dtop_info[unit]->adaptor, FALSE, TRUE);
248: }
249: }
250:
251: boolean_t
252: dtop_start(tp)
253: struct tty *tp;
254: {
255: register int line, temp;
256:
257: /* no, we do not need a char out first */
258: return FALSE;
259: }
260:
261: dtop_w_test(n, a,b,c,d,e,f,g,h)
262: {
263: int *p = (int*)0xbc2a0000;
264:
265: if (n <= 0) return;
266:
267: a <<= 8; *p = a;
268: if (--n == 0) goto out;
269: delay(20);
270: b <<= 8; *p = b;
271: if (--n == 0) goto out;
272: delay(20);
273: c <<= 8; *p = c;
274: if (--n == 0) goto out;
275: delay(20);
276: d <<= 8; *p = d;
277: if (--n == 0) goto out;
278: delay(20);
279: e <<= 8; *p = e;
280: if (--n == 0) goto out;
281: delay(20);
282: f <<= 8; *p = f;
283: if (--n == 0) goto out;
284: delay(20);
285: g <<= 8; *p = g;
286: if (--n == 0) goto out;
287: delay(20);
288: h <<= 8; *p = h;
289: out:
290: delay(10000);
291: {
292: int buf[100];
293:
294: delay(20);
295: a = *p;
296: buf[0] = a;
297: c = 1;
298: for (n = 0; n < 100; n++) {
299: delay(20);
300: b = *p;
301: if (b != a) {
302: buf[c++] = b;
303: b = a;
304: }
305: }
306: for (n = 0; n < c; n++)
307: db_printf("%x ", ((buf[n])>>8)&0xff);
308: }
309: return c;
310: }
311:
312: /*
313: * Take a packet off dtop interface
314: * A packet MUST be there, this is not checked for.
315: */
316: #define DTOP_ESC_CHAR 0xf8
317: dtop_escape(c)
318: {
319: /* I donno much about this stuff.. */
320: switch (c) {
321: case 0xe8: return 0xf8;
322: case 0xe9: return 0xf9;
323: case 0xea: return 0xfa;
324: case 0xeb: return 0xfb;
325: default: /* printf("{esc %x}", c); */
326: return c;
327: }
328: }
329:
330: dtop_get_packet(dtop, pkt)
331: dtop_softc_t dtop;
332: dtop_message_t pkt;
333: {
334: register poll_reg_t poll;
335: register data_reg_t data;
336: register int max, i, len;
337: register unsigned char c;
338:
339: poll = dtop->poll;
340: data = dtop->data;
341:
342: /*
343: * The interface does not handle us the first byte,
344: * which is our address and cannot ever be anything
345: * else but 0x50. This is a good thing, it makes
346: * the average packet exactly one word long, too.
347: */
348: pkt->src_address = DTOP_GET_BYTE(data);
349:
350: for (max = 0; (max < DTOP_MAX_POLL) && !DTOP_RX_AVAIL(poll); max++)
351: delay(16);
352: if (max == DTOP_MAX_POLL) goto bad;
353: pkt->code.bits = DTOP_GET_BYTE(data);
354:
355: /*
356: * Now get data and checksum
357: */
358: len = pkt->code.val.len + 1;
359: c = 0;
360: for (i = 0; i < len; i++) {
361:
362: again: for (max = 0; (max < DTOP_MAX_POLL) && !DTOP_RX_AVAIL(poll); max++)
363: delay(16);
364: if (max == DTOP_MAX_POLL) goto bad;
365: if (c == DTOP_ESC_CHAR) {
366: c = dtop_escape(DTOP_GET_BYTE(data) & 0xff);
367: } else {
368: c = DTOP_GET_BYTE(data);
369: if (c == DTOP_ESC_CHAR)
370: goto again;
371: }
372:
373: pkt->body[i] = c;
374: }
375: return len;
376: bad:
377: dtop->bad_pkts++;
378: return -1;
379: }
380:
381: /* Conversely... */
382: dtop_put_packet(dtop, pkt)
383: dtop_softc_t dtop;
384: dtop_message_t pkt;
385: {
386: register int i, max;
387: register unsigned char *cp;
388: register unsigned int spl;
389: register unsigned char c;
390:
391: spl = spltty();
392: pkt->src_address = pkt->dest_address;
393: i = 0;
394: cp = (unsigned char *)&pkt->src_address;
395: while (i < pkt->code.val.len + 2) {
396: for (max = 0; max < DTOP_MAX_POLL && !DTOP_TX_AVAIL(dtop->poll);
397: max++);
398: if (max == DTOP_MAX_POLL)
399: goto bad;
400: DTOP_PUT_BYTE(dtop->data, *cp);
401: cp++;
402: i++;
403: }
404: for (max = 0; (max < DTOP_MAX_POLL) && !DTOP_RX_AVAIL(dtop->poll); max++)
405: delay(16);
406: if (max == DTOP_MAX_POLL)
407: goto bad;
408: c = DTOP_GET_BYTE(dtop->data);
409: if (c == DTOP_ESC_CHAR) {
410: for (max = 0; (max < DTOP_MAX_POLL)
411: && !DTOP_RX_AVAIL(dtop->poll); max++)
412: delay(16);
413: if (max == DTOP_MAX_POLL)
414: goto bad;
415: c = DTOP_GET_BYTE(dtop->data);
416: }
417: splx(spl);
418: switch (c) {
419: case 0xfb: /* XMT, ok */
420: break;
421: default:
422: return 0;
423: }
424: return 1;
425: bad:
426: splx(spl);
427: return 0;
428: }
429:
430:
431: /*
432: * Get a char from a specific DTOP line
433: * [this is only used for console&screen purposes]
434: */
435: dtop_getc( unit, line, wait, raw )
436: boolean_t wait;
437: boolean_t raw;
438: {
439: register int c;
440: dtop_softc_t dtop;
441:
442: dtop = dtop_softc[unit];
443: again:
444: c = -1;
445:
446: /*
447: * Try rconsole first
448: */
449: if (rcline && line == SCREEN_LINE_KEYBOARD) {
450: c = scc_getc( 0, rcline, FALSE, raw);
451: if (c != -1) return c;
452: }
453:
454: /*
455: * Now check keyboard
456: */
457: if (DTOP_RX_AVAIL(dtop->poll)) {
458:
459: dtop_message msg;
460: struct dtop_ds *ds;
461:
462: if (dtop_get_packet(dtop, &msg) >= 0) {
463:
464: ds = &dtop->device[DTOP_DEVICE_NO(msg.src_address)];
465: if (ds->handler == dtop_keyboard_handler) {
466:
467: c = dtop_keyboard_handler(
468: &ds->status, &msg,
469: DTOP_EVENT_RECEIVE_PACKET, -1);
470:
471: if (c > 0) return c;
472:
473: c = -1;
474: }
475: }
476: }
477:
478: if (wait && (c == -1)) {
479: delay(100);
480: goto again;
481: }
482:
483: return c;
484: }
485:
486: /*
487: * Put a char on a specific DTOP line
488: */
489: dtop_putc( unit, line, c )
490: {
491: if (rcline && line == rcline) {
492: scc_putc(0, rcline, c);
493: }
494: /* dprintf("%c", c); */
495: }
496:
497: dtop_param(tp, line)
498: struct tty *tp;
499: {
500: if (tp->t_ispeed == 0)
501: ttymodem(tp, 0);
502: else
503: /* called too early to invoke ttymodem, sigh */
504: tp->t_state |= TS_CARR_ON;
505: }
506:
507: /*
508: * Modem control functions, we don't need 'em
509: */
510: dtop_mctl(dev, bits, how)
511: int dev;
512: int bits, how;
513: {
514: return 0;
515: }
516:
517: dtop_softCAR(unit, line, on)
518: {
519: }
520:
521: /* Some keyboard specific stuff, probably belongs elsewhere */
522:
523: dtop_kbd_probe(unit)
524: {
525: if (dtop_std[unit]) {
526: lk201_probe(unit);
527: return 1;
528: }
529: return 0;
530: }
531:
532: io_return_t
533: dtop_set_status(unit, flavor, status, status_count)
534: int unit;
535: int flavor;
536: dev_status_t status;
537: unsigned int status_count;
538: {
539: dtop_device_t dev;
540:
541: dev = &dtop_softc[unit]->device[DTOP_DEVICE_NO(0x6c)].status;
542:
543: switch (flavor) {
544: case LK201_SEND_CMD: {
545: register lk201_cmd_t *cmd = (lk201_cmd_t *)status;
546: unsigned int cnt;
547:
548: if ((status_count < (sizeof(*cmd)/sizeof(int))) ||
549: ((cnt = cmd->len) > 2))
550: return D_INVALID_SIZE;
551: switch (cmd->command) {
552: case LK_CMD_ENB_BELL:
553: cmd->params[0] ^= 0x7;
554: if (dtop_print_debug)
555: printf("LK_CMD_ENB_BELL %d\n", cmd->params[0]);
556: dev->keyboard.bell_volume = cmd->params[0] & 0x7;
557: break;
558: case LK_CMD_DIS_BELL:
559: dev->keyboard.bell_volume = 0;
560: break;
561: case LK_CMD_BELL:
562: dtop_ring_bell(unit);
563: break;
564: case LK_CMD_LEDS_ON:
565: cmd->params[0] &= ~0x80;
566: if (dtop_print_debug)
567: printf("LK_CMD_LEDS_ON %d %x\n",
568: cmd->params[0], cmd->params[0]);
569: dev->keyboard.led_status |= cmd->params[0];
570: dtop_leds(unit, dev->keyboard.led_status);
571: break;
572: case LK_CMD_LEDS_OFF:
573: cmd->params[0] &= ~0x80;
574: dev->keyboard.led_status &= ~cmd->params[0];
575: dtop_leds(unit, dev->keyboard.led_status);
576: break;
577: case LK_CMD_ENB_KEYCLK:
578: case LK_CMD_DIS_KEYCLK:
579: case LK_CMD_SOUND_CLK:
580: case LK_CMD_DIS_CTLCLK:
581: case LK_CMD_ENB_CTLCLK:
582: break;
583: default:
584: break;
585: }
586: break;
587: }
588: default:
589: break;
590: }
591: return lk201_set_status(unit, flavor, status, status_count);
592: }
593:
594: dtop_kbd_reset(unit)
595: {
596: return lk201_reset(unit);
597: }
598:
599: #define DTOP_BITS(p, len) (((p) << 7) | (len))
600:
601: dtop_ring_bell(unit)
602: {
603: dtop_message msg;
604: dtop_device_t dev;
605: int vol;
606:
607: dev = &dtop_softc[unit]->device[DTOP_DEVICE_NO(0x6c)].status;
608: vol = dev->keyboard.bell_volume;
609:
610: if (dtop_print_debug)
611: printf("dtop_ring_bell: %d\n", vol);
612: msg.dest_address = DTOP_ADDR_KBD;
613: msg.code.bits = DTOP_BITS(1, 2);
614: msg.body[0] = DTOP_KMSG_BELL;
615: msg.body[1] = vol;
616: if (!dtop_put_packet(dtop_softc[unit], &msg)) {
617: if (dtop_print_debug)
618: printf("dtop_ring_bell: dtop_put_packet failed\n");
619: return -1;
620: }
621: return 0;
622: }
623:
624: dtop_leds(unit, mask)
625: {
626: dtop_message msg;
627:
628: if (dtop_print_debug)
629: printf("dtop_leds %x\n", mask);
630: msg.dest_address = DTOP_ADDR_KBD;
631: msg.code.bits = DTOP_BITS(1, 2);
632: msg.body[0] = DTOP_KMSG_LED;
633: msg.body[1] = mask;
634: if (!dtop_put_packet(dtop_softc[unit], &msg)) {
635: if (dtop_print_debug)
636: printf("dtop_leds: dtop_put_packet failed\n");
637: return -1;
638: }
639: return 0;
640: }
641:
642:
643:
644: #endif NDTOP > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.