![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dev.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / net / tcp|
Return to dev.c CVS log | Up to [Early Linux] / linux / net / tcp |
1.1 root 1: /* dev.c */
2: /*
3: Copyright (C) 1992 Ross Biro
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License as published by
7: the Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This program is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; if not, write to the Free Software
17: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: The Author may be reached as bir7@leland.stanford.edu or
20: C/O Department of Mathematics; Stanford University; Stanford, CA 94305
21: */
22:
23: #include <asm/segment.h>
24: #include <asm/system.h>
25: #include <linux/types.h>
26: #include <linux/kernel.h>
27: #include <linux/sched.h>
28: #include <linux/string.h>
29: #include <linux/mm.h>
30: #include <linux/socket.h>
31: #include <netinet/in.h>
32: #include <asm/memory.h>
33: #include "dev.h"
34: #include "eth.h"
35: #include "timer.h"
36: #include "ip.h"
37: #include "tcp.h"
38: #include "sock.h"
39: #include <linux/errno.h>
40: #include "arp.h"
41:
42: #undef DEV_DEBUG
43: #ifdef DEV_DEBUG
44: #define PRINTK printk
45: #else
46: #define PRINTK dummy_routine
47: #endif
48:
49:
50: static unsigned long
51: min(unsigned long a, unsigned long b)
52: {
53: if (a < b) return (a);
54: return (b);
55: }
56:
57: void
58: dev_add_pack (struct packet_type *pt)
59: {
60: struct packet_type *p1;
61: pt->next = ptype_base;
62:
63: /* see if we need to copy it. */
64: for (p1 = ptype_base; p1 != NULL; p1 = p1->next)
65: {
66: if (p1->type == pt->type)
67: {
68: pt->copy = 1;
69: break;
70: }
71: }
72:
73: ptype_base = pt;
74:
75: }
76:
77: void
78: dev_remove_pack (struct packet_type *pt)
79: {
80: struct packet_type *lpt, *pt1;
81: if (pt == ptype_base)
82: {
83: ptype_base = pt->next;
84: return;
85: }
86:
87: lpt = NULL;
88:
89: for (pt1 = ptype_base; pt1->next != NULL; pt1=pt1->next)
90: {
91: if (pt1->next == pt )
92: {
93: cli();
94: if (!pt->copy && lpt)
95: lpt->copy = 0;
96: pt1->next = pt->next;
97: sti();
98: return;
99: }
100:
101: if (pt1->next -> type == pt ->type)
102: {
103: lpt = pt1->next;
104: }
105: }
106: }
107:
108: struct device *
109: get_dev (char *name)
110: {
111: struct device *dev;
112: for (dev = dev_base; dev != NULL; dev=dev->next)
113: {
114: if (strcmp (dev->name, name) == 0) return (dev);
115: }
116: return (NULL);
117: }
118:
119: void
120: dev_queue_xmit (struct sk_buff *skb, struct device *dev, int pri)
121: {
122: struct sk_buff *skb2;
123: PRINTK ("eth_queue_xmit (skb=%X, dev=%X, pri = %d)\n", skb, dev, pri);
124: skb->dev = dev;
125: if (pri < 0 || pri >= DEV_NUMBUFFS)
126: {
127: printk ("bad priority in dev_queue_xmit.\n");
128: pri = 1;
129: }
130:
131: if (dev->hard_start_xmit(skb, dev) == 0)
132: {
133: return;
134: }
135:
136: if (skb->next != NULL)
137: {
138: printk ("retransmitted packet still on queue. \n");
139: return;
140: }
141:
142: /* used to say it is not currently on a send list. */
143: skb->next = NULL;
144:
145:
146: /* put skb into a bidirectional circular linked list. */
147: PRINTK ("eth_queue dev->buffs[%d]=%X\n",pri, dev->buffs[pri]);
148: /* interrupts should already be cleared by hard_start_xmit. */
149: cli();
150: if (dev->buffs[pri] == NULL)
151: {
152: dev->buffs[pri]=skb;
153: skb->next = skb;
154: skb->prev = skb;
155: }
156: else
157: {
158: skb2=dev->buffs[pri];
159: skb->next = skb2;
160: skb->prev = skb2->prev;
161: skb->next->prev = skb;
162: skb->prev->next = skb;
163: }
164: sti();
165:
166: }
167:
168:
169: /* this routine now just gets the data out of the card and returns.
170: it's return values now mean.
171:
172: 1 <- exit even if you have more packets.
173: 0 <- call me again no matter what.
174: -1 <- last packet not processed, try again. */
175:
176: int
177: dev_rint(unsigned char *buff, unsigned long len, int flags,
178: struct device * dev)
179: {
180: struct sk_buff *skb=NULL;
181: struct packet_type *ptype;
182: unsigned short type;
183: unsigned char flag =0;
184: unsigned char *to;
185: int amount;
186:
187: /* try to grab some memory. */
188: if (len > 0 && buff != NULL)
189: {
190: skb = malloc (sizeof (*skb) + len);
191: skb->mem_len = sizeof (*skb) + len;
192: skb->mem_addr = skb;
193: }
194:
195: /* firs we copy the packet into a buffer, and save it for later. */
196: if (buff != NULL && skb != NULL)
197: {
198: if ( !(flags & IN_SKBUFF))
199: {
200: to = (unsigned char *)(skb+1);
201: while (len > 0)
202: {
203: amount = min (len, (unsigned long) dev->rmem_end -
204: (unsigned long) buff);
205: memcpy (to, buff, amount);
206: len -= amount;
207: buff += amount;
208: to += amount;
209: if ((unsigned long)buff == dev->rmem_end)
210: buff = (unsigned char *)dev->rmem_start;
211: }
212: }
213: else
214: {
215: free_s (skb->mem_addr, skb->mem_len);
216: skb = (struct sk_buff *)buff;
217: }
218:
219: skb->len = len;
220: skb->dev = dev;
221: skb->sk = NULL;
222:
223: /* now add it to the dev backlog. */
224: cli();
225: if (dev-> backlog == NULL)
226: {
227: skb->prev = skb;
228: skb->next = skb;
229: dev->backlog = skb;
230: }
231: else
232: {
233: skb ->prev = dev->backlog->prev;
234: skb->next = dev->backlog;
235: skb->next->prev = skb;
236: skb->prev->next = skb;
237: }
238: sti();
239: return (0);
240: }
241:
242: if (skb != NULL)
243: free_s (skb->mem_addr, skb->mem_len);
244:
245: /* anything left to process? */
246:
247: if (dev->backlog == NULL)
248: {
249: if (buff == NULL)
250: {
251: sti();
252: return (1);
253: }
254:
255: if (skb != NULL)
256: {
257: sti();
258: return (-1);
259: }
260:
261: sti();
262: printk ("dev_rint:Dropping packets due to lack of memory\n");
263: return (1);
264: }
265:
266: skb= dev->backlog;
267: if (skb->next == skb)
268: {
269: dev->backlog = NULL;
270: }
271: else
272: {
273: dev->backlog = skb->next;
274: skb->next->prev = skb->prev;
275: skb->prev->next = skb->next;
276: }
277: sti();
278:
279: /* bump the pointer to the next structure. */
280: skb->h.raw = (unsigned char *)(skb+1) + dev->hard_header_len;
281: skb->len -= dev->hard_header_len;
282:
283: /* convert the type to an ethernet type. */
284: type = dev->type_trans (skb, dev);
285:
286: /* if there get to be a lot of types we should changes this to
287: a bunch of linked lists like we do for ip protocols. */
288: for (ptype = ptype_base; ptype != NULL; ptype=ptype->next)
289: {
290: if (ptype->type == type)
291: {
292: struct sk_buff *skb2;
293: /* copy the packet if we need to. */
294: if (ptype->copy)
295: {
296: skb2 = malloc (skb->mem_len);
297: if (skb2 == NULL) continue;
298: memcpy (skb2, skb, skb->mem_len);
299: skb2->mem_addr = skb2;
300: }
301: else
302: {
303: skb2 = skb;
304: flag = 1;
305: }
306:
307: ptype->func (skb2, dev, ptype);
308: }
309: }
310:
311: if (!flag)
312: {
313: PRINTK ("discarding packet type = %X\n", type);
314: free_skb (skb, FREE_READ);
315: }
316:
317: if (buff == NULL)
318: return (0);
319: else
320: return (-1);
321: }
322:
323: /* This routine is called when an device interface is ready to
324: transmit a packet. Buffer points to where the packet should
325: be put, and the routine returns the length of the packet. A
326: length of zero is interrpreted to mean the transmit buffers
327: are empty, and the transmitter should be shut down. */
328:
329: unsigned long
330: dev_tint(unsigned char *buff, struct device *dev)
331: {
332: int i;
333: int tmp;
334: struct sk_buff *skb;
335: for (i=0; i < DEV_NUMBUFFS; i++)
336: {
337: while (dev->buffs[i]!=NULL)
338: {
339: cli();
340: skb=dev->buffs[i];
341: if (skb->next == skb)
342: {
343: dev->buffs[i] = NULL;
344: }
345: else
346: {
347: dev->buffs[i]=skb->next;
348: skb->prev->next = skb->next;
349: skb->next->prev = skb->prev;
350: }
351: skb->next = NULL;
352: skb->prev = NULL;
353: sti();
354: tmp = skb->len;
355: if (!skb->arp)
356: {
357: if (dev->rebuild_header (skb+1, dev))
358: {
359: skb->dev = dev;
360: arp_queue (skb);
361: continue;
362: }
363: }
364:
365: if (tmp <= dev->mtu)
366: {
367: if (dev->send_packet != NULL)
368: {
369: dev->send_packet(skb, dev);
370: }
371: if (buff != NULL)
372: memcpy (buff, skb + 1, tmp);
373:
374: PRINTK (">>\n");
375: print_eth ((struct enet_header *)(skb+1));
376: }
377: else
378: {
379: printk ("**** bug len bigger than mtu. \n");
380: }
381:
382: if (skb->free)
383: {
384: free_skb(skb, FREE_WRITE);
385: }
386:
387: if (tmp != 0)
388: return (tmp);
389: }
390: }
391: PRINTK ("dev_tint returning 0 \n");
392: return (0);
393: }
394: