![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_par.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to if_par.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1993,1991,1990,1989 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: * Parallel port network driver v1.1
28: * All rights reserved.
29: */
30:
31: /*
32: Subject: parallel network interface
33:
34: The printer network driver has the following hardware requirements for the
35: interconnection cable:
36:
37: Connections:
38: Side1 Side2 Function Side1 / Side2
39: Pin 5 Pin 10 Interrupt strobe: send status (w)/send status (r)
40: Pin 2 Pin 15 Data bits : write / read
41: Pin 3 Pin 13 Data bits : write / read
42: Pin 4 Pin 12 Data bits : write / read
43: Pin 6 Pin 11 Data bits : write / read
44: Pin 10 Pin 5
45: Pin 11 Pin 6
46: Pin 12 Pin 4
47: Pin 13 Pin 3
48: Pin 15 Pin 2
49: Pins 18-25 Pins 18-25 (ground interconnections)
50:
51: The cable is "symmetric" in that either side can be plugged into either of the
52: computers.
53:
54: The hardware requirements are as follows:
55: Port 0x378 must be writable with the following specifications:
56: Bit 4 -> pin 6
57: Bit 3 -> pin 5
58: Bit 2 -> pin 4
59: Bit 1 -> pin 3
60: Bit 0 -> pin 2
61: Port 0x379 must be readable with the following specifications:
62: Bit 7 <- pin 11
63: Bit 6 <- pin 10
64: Bit 5 <- pin 12
65: Bit 4 <- pin 13
66: Bit 3 <- pin 15
67: Port 0x37a must be readable and writable with the following specifications:
68: Bit 4 -> interrupt enable
69: So Port 0x378 connects to Port 0x379 as
70: Bit 3 -> pin 5 : pin 10 -> Bit 6 0x08 -> 0x40
71:
72: Bit 4 -> pin 6 : pin 11 -> Bit 7 0x08<<1 -> ~ 0x80
73: Bit 2 -> pin 4 : pin 12 -> Bit 5 0x07 -> 0x38
74: Bit 1 -> pin 3 : pin 13 -> Bit 4 0x07 -> 0x38
75: Bit 0 -> pin 2 : pin 15 -> Bit 3 0x07 -> 0x38
76: [note: bit 0 is considered the least significant bit, pins on the connector
77: are numbered starting with 1, -> represents sending data out on the bus, <-
78: represents reading data from the bus]
79:
80: Pins 1,7,8,9, and 16 are currently unused, and may be allowed to "float".
81:
82: The data is sent in 4 bit "nybbles", with the highest 4 bits being sent first.
83:
84: To bring up the interface, all that should be required is
85: ifconfig par0 <your ip address> <connected machine's ip address> up
86: and to bring down the interface
87: ifconfig par0 down
88: You may get a warning message (such as printer out of paper) once you down
89: the interface, as the port is monitored for both printer and network activity
90: depending on whether par0 is up or down, and when you down the interface the
91: printer driver will then read whatever is on the port (which will be the last
92: message from the other computer).
93: */
94:
95: #include <par.h>
96: #if NPAR > 0
97:
98: #include <kern/time_out.h>
99: #include <device/device_types.h>
100: #include <device/errno.h>
101: #include <device/io_req.h>
102: #include <device/if_hdr.h>
103: #include <device/if_ether.h>
104: #include <device/net_status.h>
105: #include <device/net_io.h>
106:
107: #include <i386/ipl.h>
108: #include <i386/pio.h>
109: #include <chips/busses.h>
110: #include <i386at/if_par.h>
111:
112:
113: int parintr();
114: int parioctl();
115: int parattach();
116: int paroutput();
117:
118: int (*oldvect)();
119: int oldunit;
120:
121: extern struct bus_device *lprinfo[];
122:
123: int par_watch = 0;
124:
125: struct par_softc {
126: struct ifnet ds_if;
127: u_char ds_addr[6]; /* Ethernet hardware address */
128: u_char address[6];
129: char sc_buf[PARMTU+sizeof(struct ifnet *)];
130: } par_softc[NPAR];
131:
132: void parintoff(unit)
133: int unit;
134: {
135: struct bus_device *lpdev = lprinfo[unit];
136:
137: outb(INTR(lpdev->address), 0x07);
138: par_softc[unit].ds_if.if_flags &= ~IFF_RUNNING;
139: ivect[lpdev->sysdep1] = oldvect;
140: iunit[lpdev->sysdep1] = oldunit;
141: }
142:
143: void parinit(unit)
144: int unit;
145: {
146: struct bus_device *lpdev = lprinfo[unit];
147:
148: if (ivect[lpdev->sysdep1] != parintr) {
149: oldvect = ivect[lpdev->sysdep1];
150: oldunit = iunit[lpdev->sysdep1];
151: ivect[lpdev->sysdep1] = parintr;
152: iunit[lpdev->sysdep1] = unit;
153: }
154: outb(INTR(lpdev->address),0x11);
155: par_softc[unit].ds_if.if_flags |= IFF_RUNNING;
156: *(struct ifnet **)par_softc[unit].sc_buf = &par_softc[unit].ds_if;
157: }
158:
159: struct ether_header par_eh;
160:
161: int parattach(dev)
162: struct bus_device *dev;
163: {
164: u_char unit = (u_char)dev->unit;
165: struct ifnet *ifp;
166: struct par_softc*sp;
167:
168: if ((unit < 0) || (unit >= NPAR))
169: return(0);
170: printf("\n par%d: at lpr%d, port = %x, spl = %d, pic = %d. ",
171: unit, unit, dev->address, dev->sysdep, dev->sysdep1);
172:
173: sp = &par_softc[unit];
174: ifp = &(sp->ds_if);
175:
176: *(sp->ds_addr) = *(sp->address) = 0x11;
177: *(sp->ds_addr + 1) = *(sp->address + 1) = 0x22;
178: *(sp->ds_addr + 2) = *(sp->address + 2) = 0x33;
179: *(sp->ds_addr + 3) = *(sp->address + 3) = 0x44;
180: *(sp->ds_addr + 4) = *(sp->address + 4) = 0x55;
181: *(sp->ds_addr + 5) = *(sp->address + 5) = 0x66;
182:
183: par_eh.ether_dhost[5] = par_eh.ether_shost[0] = 0x11;
184: par_eh.ether_dhost[4] = par_eh.ether_shost[1] = 0x22;
185: par_eh.ether_dhost[3] = par_eh.ether_shost[2] = 0x33;
186: par_eh.ether_dhost[2] = par_eh.ether_shost[3] = 0x44;
187: par_eh.ether_dhost[1] = par_eh.ether_shost[4] = 0x55;
188: par_eh.ether_dhost[0] = par_eh.ether_shost[5] = 0x66;
189: par_eh.ether_type = htons(0x0800);
190:
191: printf("ethernet id [%x:%x:%x:%x:%x:%x]",
192: sp->address[0],sp->address[1],sp->address[2],
193: sp->address[3],sp->address[4],sp->address[5]);
194:
195: ifp->if_unit = unit;
196: ifp->if_mtu = ETHERMTU;
197: ifp->if_flags = IFF_POINTOPOINT;
198: ifp->if_header_size = sizeof(struct ether_header);
199: ifp->if_header_format = HDR_ETHERNET;
200: ifp->if_address_size = 6;
201: ifp->if_address = (char *)&par_softc[unit].address[0];
202: if_init_queues(ifp);
203: return(0);
204: }
205:
206: int parstart(); /* forward */
207:
208: /*ARGSUSED*/
209: paropen(dev, flag)
210: dev_t dev;
211: int flag;
212: {
213: register int unit = minor(dev);
214:
215: if (unit < 0 || unit >= NPAR)
216: return (ENXIO);
217:
218: par_softc[unit].ds_if.if_flags |= IFF_UP;
219: parinit(unit);
220: return(0);
221: }
222:
223: paroutput(dev, ior)
224: dev_t dev;
225: io_req_t ior;
226: {
227: register int unit = minor(dev);
228:
229: if (unit < 0 || unit >= NPAR)
230: return (ENXIO);
231: return (net_write(&par_softc[unit].ds_if, parstart, ior));
232: }
233:
234: parsetinput(dev, receive_port, priority, filter, filter_count)
235: dev_t dev;
236: mach_port_t receive_port;
237: int priority;
238: filter_t filter[];
239: unsigned int filter_count;
240: {
241: register int unit = minor(dev);
242:
243: if (unit < 0 || unit >= NPAR)
244: return (ENXIO);
245:
246: return (net_set_filter(&par_softc[unit].ds_if,
247: receive_port, priority,
248: filter, filter_count));
249: }
250:
251: int parstart(unit)
252: {
253: struct ifnet *ifp = &(par_softc[unit].ds_if);
254: u_short addr = lprinfo[unit]->address;
255: struct sockaddr *dst;
256: int len, i;
257: spl_t s;
258: u_char *mcp, c;
259: io_req_t m;
260:
261: if (!(ifp->if_flags & IFF_RUNNING)) {
262: #ifdef WHY
263: m_free(m);
264: parintoff(unit);
265: return(ENETDOWN);
266: #else WHY
267: parintoff(unit);
268: return(-1);
269: #endif WHY
270: }
271: s = SPLNET();
272:
273: IF_DEQUEUE(&ifp->if_snd, m);
274: if (m == 0) {
275: splx(s);
276: return 0;
277: }
278: len = m->io_count;
279: if (par_watch)
280: printf("O%d\n",len);
281: len -= 14 /* XXX */;
282: mcp = (u_char *)m->io_data + 14 /* XXX */;
283: while (len--) {
284: c=*mcp++;
285: outb(OUTPUT(addr),((c&0x80)>>3) | ((c&0x70)>>4) | 0x08);
286: i=MAXSPIN;
287: while (!(inb(INPUT(addr))&0x40) && --i);
288: outb(OUTPUT(addr),((c&0x08)<<1) | (c&0x07));
289: i=MAXSPIN;
290: while ((inb(INPUT(addr))&0x40) && --i);
291: }
292: outb(OUTPUT(addr),(((c&0x08)<<1) | (c&0x07))^0x17);
293: iodone(m);
294: splx(s);
295: return (0);
296: }
297:
298: /*ARGSUSED*/
299: pargetstat(dev, flavor, status, count)
300: dev_t dev;
301: int flavor;
302: dev_status_t status; /* pointer to OUT array */
303: unsigned int *count; /* out */
304: {
305: register int unit = minor(dev);
306:
307: if (unit < 0 || unit >= NPAR)
308: return (ENXIO);
309:
310:
311: switch (flavor) {
312: case NET_DSTADDR:
313: return (D_SUCCESS);
314: break;
315: }
316:
317: return (net_getstat(&par_softc[unit].ds_if,
318: flavor,
319: status,
320: count));
321: }
322:
323: parsetstat(dev, flavor, status, count)
324: dev_t dev;
325: int flavor;
326: dev_status_t status;
327: unsigned int count;
328: {
329: register int unit = minor(dev);
330: register struct par_softc *sp;
331:
332: if (unit < 0 || unit >= NPAR)
333: return (ENXIO);
334:
335: sp = &par_softc[unit];
336:
337: switch (flavor) {
338: case NET_STATUS:
339: {
340: /*
341: * All we can change are flags, and not many of those.
342: */
343: register struct net_status *ns = (struct net_status *)status;
344: int mode = 0;
345:
346: if (count < NET_STATUS_COUNT)
347: return (D_INVALID_SIZE);
348:
349: #if 0
350: /* ha ha ha */
351: if (ns->flags & IFF_ALLMULTI)
352: mode |= MOD_ENAL;
353: if (ns->flags & IFF_PROMISC)
354: mode |= MOD_PROM;
355: /*
356: * Force a complete reset if the receive mode changes
357: * so that these take effect immediately.
358: */
359: if (sp->mode != mode) {
360: sp->mode = mode;
361: if (sp->flags & DSF_RUNNING) {
362: sp->flags &= ~(DSF_LOCK | DSF_RUNNING);
363: parinit(unit);
364: }
365: }
366: #endif
367: break;
368: }
369: case NET_ADDRESS:
370: {
371: register union ether_cvt {
372: char addr[6];
373: int lwd[2];
374: } *ec = (union ether_cvt *)status;
375:
376: if (count < sizeof(*ec)/sizeof(int))
377: return (D_INVALID_SIZE);
378:
379: ec->lwd[0] = ntohl(ec->lwd[0]);
380: ec->lwd[1] = ntohl(ec->lwd[1]);
381: /* at3c501seteh(sp->base, ec->addr);*/
382: break;
383: }
384:
385: default:
386: return (D_INVALID_OPERATION);
387: }
388: return (D_SUCCESS);
389: }
390:
391: int parintr(unit)
392: int unit;
393: {
394: register struct par_softc *sp = &par_softc[unit];
395: u_short addr = lprinfo[unit]->address;
396: char *trav = sp->sc_buf;
397: short len = 0;
398: u_char c, c2;
399: int i;
400: ipc_kmsg_t new_kmsg;
401: struct ether_header *ehp;
402: struct packet_header *pkt;
403: struct ifnet *ifp = &(sp->ds_if);
404:
405: do {
406: c2=inb(INPUT(addr));
407: outb(OUTPUT(addr),0x08);
408: i=MAXSPIN;
409: while(((c=inb(INPUT(addr)))&0x40) && --i);
410:
411: c = inb(INPUT(addr));
412: outb(OUTPUT(addr),0x00);
413: if (!i)
414: break;
415:
416: if (++len > ETHERMTU) {
417: trav = sp->sc_buf;
418: len = 0;
419: continue;
420: }
421: *trav++ = ((~c2)&0x80) | ((c2&0x38)<<1) | (((~c)&0x80)>>4) | ((c&0x38)>>3);
422: i=MAXSPIN;
423: while (!((c2=inb(INPUT(addr)))&0x40) && --i)
424: if (((c2^0xb8)&0xf8) == (c&0xf8))
425: goto end;
426: } while (i);
427: end:
428: if (len < 20) /* line noise ? */
429: return;
430: if (par_watch)
431: printf("I%d\n",len);
432:
433: new_kmsg = net_kmsg_get();
434: if (new_kmsg == IKM_NULL) {
435: /*
436: * Drop the packet.
437: */
438: sp->ds_if.if_rcvdrops++;
439: return;
440: }
441: ehp = (struct ether_header *) (&net_kmsg(new_kmsg)->header[0]);
442: pkt = (struct packet_header *) (&net_kmsg(new_kmsg)->packet[0]);
443: *ehp = par_eh;
444:
445: bcopy (sp->sc_buf, (char *) (pkt + 1), len);
446:
447: pkt->type = ehp->ether_type;
448: pkt->length = len + sizeof(struct packet_header);
449: /*
450: * Hand the packet to the network module.
451: */
452: net_packet(ifp, new_kmsg, pkt->length,
453: ethernet_priority(new_kmsg));
454: return(0);
455: }
456: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.