1 /*
2 * Copyright 1996 The Board of Trustees of The Leland Stanford
3 * Junior University. All Rights Reserved.
4 *
5 * Permission to use, copy, modify, and distribute this
6 * software and its documentation for any purpose and without
7 * fee is hereby granted, provided that the above copyright
8 * notice appear in all copies. Stanford University
9 * makes no representations about the suitability of this
10 * software for any purpose. It is provided "as is" without
11 * express or implied warranty.
12 *
13 * strip.c This module implements Starmode Radio IP (STRIP)
14 * for kernel-based devices like TTY. It interfaces between a
15 * raw TTY, and the kernel's INET protocol layers (via DDI).
16 *
17 * Version: @(#)strip.c 1.3 July 1997
18 *
19 * Author: Stuart Cheshire <cheshire@cs.stanford.edu>
20 *
21 * Fixes: v0.9 12th Feb 1996 (SC)
22 * New byte stuffing (2+6 run-length encoding)
23 * New watchdog timer task
24 * New Protocol key (SIP0)
25 *
26 * v0.9.1 3rd March 1996 (SC)
27 * Changed to dynamic device allocation -- no more compile
28 * time (or boot time) limit on the number of STRIP devices.
29 *
30 * v0.9.2 13th March 1996 (SC)
31 * Uses arp cache lookups (but doesn't send arp packets yet)
32 *
33 * v0.9.3 17th April 1996 (SC)
34 * Fixed bug where STR_ERROR flag was getting set unneccessarily
35 * (causing otherwise good packets to be unneccessarily dropped)
36 *
37 * v0.9.4 27th April 1996 (SC)
38 * First attempt at using "&COMMAND" Starmode AT commands
39 *
40 * v0.9.5 29th May 1996 (SC)
41 * First attempt at sending (unicast) ARP packets
42 *
43 * v0.9.6 5th June 1996 (Elliot)
44 * Put "message level" tags in every "printk" statement
45 *
46 * v0.9.7 13th June 1996 (laik)
47 * Added support for the /proc fs
48 *
49 * v0.9.8 July 1996 (Mema)
50 * Added packet logging
51 *
52 * v1.0 November 1996 (SC)
53 * Fixed (severe) memory leaks in the /proc fs code
54 * Fixed race conditions in the logging code
55 *
56 * v1.1 January 1997 (SC)
57 * Deleted packet logging (use tcpdump instead)
58 * Added support for Metricom Firmware v204 features
59 * (like message checksums)
60 *
61 * v1.2 January 1997 (SC)
62 * Put portables list back in
63 *
64 * v1.3 July 1997 (SC)
65 * Made STRIP driver set the radio's baud rate automatically.
66 * It is no longer necessarily to manually set the radio's
67 * rate permanently to 115200 -- the driver handles setting
68 * the rate automatically.
69 */
70
71 #ifdef MODULE
72 static const char StripVersion[] = "1.3-STUART.CHESHIRE-MODULAR";
73 #else
74 static const char StripVersion[] = "1.3-STUART.CHESHIRE";
75 #endif
76
77 #define TICKLE_TIMERS 0
78 #define EXT_COUNTERS 1
79
80
81 /************************************************************************/
82 /* Header files */
83
84 #include <linux/config.h>
85
86 #ifdef MODULE
87 #include <linux/module.h>
88 #include <linux/version.h>
89 #endif
90
91 #include <asm/system.h>
92 #include <asm/uaccess.h>
93 #include <asm/segment.h>
94 #include <asm/bitops.h>
95
96 /*
97 * isdigit() and isspace() use the ctype[] array, which is not available
98 * to kernel modules. If compiling as a module, use a local definition
99 * of isdigit() and isspace() until _ctype is added to ksyms.
100 */
101 #ifdef MODULE
102 # define isdigit(c) ('' <= (c) && (c) <= '9')
103 # define isspace(c) ((c) == ' ' || (c) == '\t')
104 #else
105 # include <linux/ctype.h>
106 #endif
107
108 #include <linux/string.h>
109 #include <linux/mm.h>
110 #include <linux/interrupt.h>
111 #include <linux/in.h>
112 #include <linux/tty.h>
113 #include <linux/errno.h>
114 #include <linux/netdevice.h>
115 #include <linux/inetdevice.h>
116 #include <linux/etherdevice.h>
117 #include <linux/skbuff.h>
118 #include <linux/if_arp.h>
119 #include <linux/if_strip.h>
120 #include <linux/proc_fs.h>
121 #include <linux/serial.h>
122 #include <linux/serialP.h>
123 #include <net/arp.h>
124
125 #include <linux/ip.h>
126 #include <linux/tcp.h>
127 #include <linux/time.h>
128
129
130 /************************************************************************/
131 /* Useful structures and definitions */
132
133 /*
134 * A MetricomKey identifies the protocol being carried inside a Metricom
135 * Starmode packet.
136 */
137
138 typedef union
139 {
140 __u8 c[4];
141 __u32 l;
142 } MetricomKey;
143
144 /*
145 * An IP address can be viewed as four bytes in memory (which is what it is) or as
146 * a single 32-bit long (which is convenient for assignment, equality testing etc.)
147 */
148
149 typedef union
150 {
151 __u8 b[4];
152 __u32 l;
153 } IPaddr;
154
155 /*
156 * A MetricomAddressString is used to hold a printable representation of
157 * a Metricom address.
158 */
159
160 typedef struct
161 {
162 __u8 c[24];
163 } MetricomAddressString;
164
165 /* Encapsulation can expand packet of size x to 65/64x + 1
166 * Sent packet looks like "<CR>*<address>*<key><encaps payload><CR>"
167 * 1 1 1-18 1 4 ? 1
168 * eg. <CR>*0000-1234*SIP0<encaps payload><CR>
169 * We allow 31 bytes for the stars, the key, the address and the <CR>s
170 */
171 #define STRIP_ENCAP_SIZE(X) (32 + (X)*65L/64L)
172
173 /*
174 * A STRIP_Header is never really sent over the radio, but making a dummy
175 * header for internal use within the kernel that looks like an Ethernet
176 * header makes certain other software happier. For example, tcpdump
177 * already understands Ethernet headers.
178 */
179
180 typedef struct
181 {
182 MetricomAddress dst_addr; /* Destination address, e.g. "0000-1234" */
183 MetricomAddress src_addr; /* Source address, e.g. "0000-5678" */
184 unsigned short protocol; /* The protocol type, using Ethernet codes */
185 } STRIP_Header;
186
187 typedef struct
188 {
189 char c[60];
190 } MetricomNode;
191
192 #define NODE_TABLE_SIZE 32
193 typedef struct
194 {
195 struct timeval timestamp;
196 int num_nodes;
197 MetricomNode node[NODE_TABLE_SIZE];
198 } MetricomNodeTable;
199
200 enum { FALSE = 0, TRUE = 1 };
201
202 /*
203 * Holds the radio's firmware version.
204 */
205 typedef struct
206 {
207 char c[50];
208 } FirmwareVersion;
209
210 /*
211 * Holds the radio's serial number.
212 */
213 typedef struct
214 {
215 char c[18];
216 } SerialNumber;
217
218 /*
219 * Holds the radio's battery voltage.
220 */
221 typedef struct
222 {
223 char c[11];
224 } BatteryVoltage;
225
226 typedef struct
227 {
228 char c[8];
229 } char8;
230
231 enum
232 {
233 NoStructure = 0, /* Really old firmware */
234 StructuredMessages = 1, /* Parsable AT response msgs */
235 ChecksummedMessages = 2 /* Parsable AT response msgs with checksums */
236 } FirmwareLevel;
237
238 struct strip
239 {
240 int magic;
241 /*
242 * These are pointers to the malloc()ed frame buffers.
243 */
244
245 unsigned char *rx_buff; /* buffer for received IP packet*/
246 unsigned char *sx_buff; /* buffer for received serial data*/
247 int sx_count; /* received serial data counter */
248 int sx_size; /* Serial buffer size */
249 unsigned char *tx_buff; /* transmitter buffer */
250 unsigned char *tx_head; /* pointer to next byte to XMIT */
251 int tx_left; /* bytes left in XMIT queue */
252 int tx_size; /* Serial buffer size */
253
254 /*
255 * STRIP interface statistics.
256 */
257
258 unsigned long rx_packets; /* inbound frames counter */
259 unsigned long tx_packets; /* outbound frames counter */
260 unsigned long rx_errors; /* Parity, etc. errors */
261 unsigned long tx_errors; /* Planned stuff */
262 unsigned long rx_dropped; /* No memory for skb */
263 unsigned long tx_dropped; /* When MTU change */
264 unsigned long rx_over_errors; /* Frame bigger then STRIP buf. */
265
266 unsigned long pps_timer; /* Timer to determine pps */
267 unsigned long rx_pps_count; /* Counter to determine pps */
268 unsigned long tx_pps_count; /* Counter to determine pps */
269 unsigned long sx_pps_count; /* Counter to determine pps */
270 unsigned long rx_average_pps; /* rx packets per second * 8 */
271 unsigned long tx_average_pps; /* tx packets per second * 8 */
272 unsigned long sx_average_pps; /* sent packets per second * 8 */
273
274 #ifdef EXT_COUNTERS
275 unsigned long rx_bytes; /* total received bytes */
276 unsigned long tx_bytes; /* total received bytes */
277 unsigned long rx_rbytes; /* bytes thru radio i/f */
278 unsigned long tx_rbytes; /* bytes thru radio i/f */
279 unsigned long rx_sbytes; /* tot bytes thru serial i/f */
280 unsigned long tx_sbytes; /* tot bytes thru serial i/f */
281 unsigned long rx_ebytes; /* tot stat/err bytes */
282 unsigned long tx_ebytes; /* tot stat/err bytes */
283 #endif
284
285 /*
286 * Internal variables.
287 */
288
289 struct strip *next; /* The next struct in the list */
290 struct strip **referrer; /* The pointer that points to us*/
291 int discard; /* Set if serial error */
292 int working; /* Is radio working correctly? */
293 int firmware_level; /* Message structuring level */
294 int next_command; /* Next periodic command */
295 unsigned int user_baud; /* The user-selected baud rate */
296 int mtu; /* Our mtu (to spot changes!) */
297 long watchdog_doprobe; /* Next time to test the radio */
298 long watchdog_doreset; /* Time to do next reset */
299 long gratuitous_arp; /* Time to send next ARP refresh*/
300 long arp_interval; /* Next ARP interval */
301 struct timer_list idle_timer; /* For periodic wakeup calls */
302 MetricomAddress true_dev_addr; /* True address of radio */
303 int manual_dev_addr; /* Hack: See note below */
304
305 FirmwareVersion firmware_version; /* The radio's firmware version */
306 SerialNumber serial_number; /* The radio's serial number */
307 BatteryVoltage battery_voltage; /* The radio's battery voltage */
308
309 /*
310 * Other useful structures.
311 */
312
313 struct tty_struct *tty; /* ptr to TTY structure */
314 struct net_device dev; /* Our device structure */
315
316 /*
317 * Neighbour radio records
318 */
319
320 MetricomNodeTable portables;
321 MetricomNodeTable poletops;
322 };
323
324 /*
325 * Note: manual_dev_addr hack
326 *
327 * It is not possible to change the hardware address of a Metricom radio,
328 * or to send packets with a user-specified hardware source address, thus
329 * trying to manually set a hardware source address is a questionable
330 * thing to do. However, if the user *does* manually set the hardware
331 * source address of a STRIP interface, then the kernel will believe it,
332 * and use it in certain places. For example, the hardware address listed
333 * by ifconfig will be the manual address, not the true one.
334 * (Both addresses are listed in /proc/net/strip.)
335 * Also, ARP packets will be sent out giving the user-specified address as
336 * the source address, not the real address. This is dangerous, because
337 * it means you won't receive any replies -- the ARP replies will go to
338 * the specified address, which will be some other radio. The case where
339 * this is useful is when that other radio is also connected to the same
340 * machine. This allows you to connect a pair of radios to one machine,
341 * and to use one exclusively for inbound traffic, and the other
342 * exclusively for outbound traffic. Pretty neat, huh?
343 *
344 * Here's the full procedure to set this up:
345 *
346 * 1. "slattach" two interfaces, e.g. st0 for outgoing packets,
347 * and st1 for incoming packets
348 *
349 * 2. "ifconfig" st0 (outbound radio) to have the hardware address
350 * which is the real hardware address of st1 (inbound radio).
351 * Now when it sends out packets, it will masquerade as st1, and
352 * replies will be sent to that radio, which is exactly what we want.
353 *
354 * 3. Set the route table entry ("route add default ..." or
355 * "route add -net ...", as appropriate) to send packets via the st0
356 * interface (outbound radio). Do not add any route which sends packets
357 * out via the st1 interface -- that radio is for inbound traffic only.
358 *
359 * 4. "ifconfig" st1 (inbound radio) to have hardware address zero.
360 * This tells the STRIP driver to "shut down" that interface and not
361 * send any packets through it. In particular, it stops sending the
362 * periodic gratuitous ARP packets that a STRIP interface normally sends.
363 * Also, when packets arrive on that interface, it will search the
364 * interface list to see if there is another interface who's manual
365 * hardware address matches its own real address (i.e. st0 in this
366 * example) and if so it will transfer ownership of the skbuff to
367 * that interface, so that it looks to the kernel as if the packet
368 * arrived on that interface. This is necessary because when the
369 * kernel sends an ARP packet on st0, it expects to get a reply on
370 * st0, and if it sees the reply come from st1 then it will ignore
371 * it (to be accurate, it puts the entry in the ARP table, but
372 * labelled in such a way that st0 can't use it).
373 *
374 * Thanks to Petros Maniatis for coming up with the idea of splitting
375 * inbound and outbound traffic between two interfaces, which turned
376 * out to be really easy to implement, even if it is a bit of a hack.
377 *
378 * Having set a manual address on an interface, you can restore it
379 * to automatic operation (where the address is automatically kept
380 * consistent with the real address of the radio) by setting a manual
381 * address of all ones, e.g. "ifconfig st0 hw strip FFFFFFFFFFFF"
382 * This 'turns off' manual override mode for the device address.
383 *
384 * Note: The IEEE 802 headers reported in tcpdump will show the *real*
385 * radio addresses the packets were sent and received from, so that you
386 * can see what is really going on with packets, and which interfaces
387 * they are really going through.
388 */
389
390
391 /************************************************************************/
392 /* Constants */
393
394 /*
395 * CommandString1 works on all radios
396 * Other CommandStrings are only used with firmware that provides structured responses.
397 *
398 * ats319=1 Enables Info message for node additions and deletions
399 * ats319=2 Enables Info message for a new best node
400 * ats319=4 Enables checksums
401 * ats319=8 Enables ACK messages
402 */
403
404 static const int MaxCommandStringLength = 32;
405 static const int CompatibilityCommand = 1;
406
407 static const char CommandString0[] = "*&COMMAND*ATS319=7"; /* Turn on checksums & info messages */
408 static const char CommandString1[] = "*&COMMAND*ATS305?"; /* Query radio name */
409 static const char CommandString2[] = "*&COMMAND*ATS325?"; /* Query battery voltage */
410 static const char CommandString3[] = "*&COMMAND*ATS300?"; /* Query version information */
411 static const char CommandString4[] = "*&COMMAND*ATS311?"; /* Query poletop list */
412 static const char CommandString5[] = "*&COMMAND*AT~LA"; /* Query portables list */
413 typedef struct { const char *string; long length; } StringDescriptor;
414
415 static const StringDescriptor CommandString[] =
416 {
417 { CommandString0, sizeof(CommandString0)-1 },
418 { CommandString1, sizeof(CommandString1)-1 },
419 { CommandString2, sizeof(CommandString2)-1 },
420 { CommandString3, sizeof(CommandString3)-1 },
421 { CommandString4, sizeof(CommandString4)-1 },
422 { CommandString5, sizeof(CommandString5)-1 }
423 };
424
425 #define GOT_ALL_RADIO_INFO(S) \
426 ((S)->firmware_version.c[0] && \
427 (S)->battery_voltage.c[0] && \
428 memcmp(&(S)->true_dev_addr, zero_address.c, sizeof(zero_address)))
429
430 static const char hextable[16] = "0123456789ABCDEF";
431
432 static const MetricomAddress zero_address;
433 static const MetricomAddress broadcast_address = { { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF } };
434
435 static const MetricomKey SIP0Key = { { "SIP0" } };
436 static const MetricomKey ARP0Key = { { "ARP0" } };
437 static const MetricomKey ATR_Key = { { "ATR " } };
438 static const MetricomKey ACK_Key = { { "ACK_" } };
439 static const MetricomKey INF_Key = { { "INF_" } };
440 static const MetricomKey ERR_Key = { { "ERR_" } };
441
442 static const long MaxARPInterval = 60 * HZ; /* One minute */
443
444 /*
445 * Maximum Starmode packet length is 1183 bytes. Allowing 4 bytes for
446 * protocol key, 4 bytes for checksum, one byte for CR, and 65/64 expansion
447 * for STRIP encoding, that translates to a maximum payload MTU of 1155.
448 * Note: A standard NFS 1K data packet is a total of 0x480 (1152) bytes
449 * long, including IP header, UDP header, and NFS header. Setting the STRIP
450 * MTU to 1152 allows us to send default sized NFS packets without fragmentation.
451 */
452 static const unsigned short MAX_SEND_MTU = 1152;
453 static const unsigned short MAX_RECV_MTU = 1500; /* Hoping for Ethernet sized packets in the future! */
454 static const unsigned short DEFAULT_STRIP_MTU = 1152;
455 static const int STRIP_MAGIC = 0x5303;
456 static const long LongTime = 0x7FFFFFFF;
457
458
459 /************************************************************************/
460 /* Global variables */
461
462 static struct strip *struct_strip_list = NULL;
463
464
465 /************************************************************************/
466 /* Macros */
467
468 /* Returns TRUE if text T begins with prefix P */
469 #define has_prefix(T,L,P) (((L) >= sizeof(P)-1) && !strncmp((T), (P), sizeof(P)-1))
470
471 /* Returns TRUE if text T of length L is equal to string S */
472 #define text_equal(T,L,S) (((L) == sizeof(S)-1) && !strncmp((T), (S), sizeof(S)-1))
473
474 #define READHEX(X) ((X)>='' && (X)<='9' ? (X)-'' : \
475 (X)>='a' && (X)<='f' ? (X)-'a'+10 : \
476 (X)>='A' && (X)<='F' ? (X)-'A'+10 : 0 )
477
478 #define READHEX16(X) ((__u16)(READHEX(X)))
479
480 #define READDEC(X) ((X)>='' && (X)<='9' ? (X)-'' : 0)
481
482 #define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
483 #define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
484 #define ELEMENTS_OF(X) (sizeof(X) / sizeof((X)[0]))
485 #define ARRAY_END(X) (&((X)[ELEMENTS_OF(X)]))
486
487 #define JIFFIE_TO_SEC(X) ((X) / HZ)
488
489
490 /************************************************************************/
491 /* Utility routines */
492
493 typedef unsigned long InterruptStatus;
494
495 extern __inline__ InterruptStatus DisableInterrupts(void)
496 {
497 InterruptStatus x;
498 save_flags(x);
499 cli();
500 return(x);
501 }
502
503 extern __inline__ void RestoreInterrupts(InterruptStatus x)
504 {
505 restore_flags(x);
506 }
507
508 static int arp_query(unsigned char *haddr, u32 paddr, struct net_device * dev)
509 {
510 struct neighbour *neighbor_entry;
511
512 neighbor_entry = neigh_lookup(&arp_tbl, &paddr, dev);
513
514 if (neighbor_entry != NULL)
515 {
516 neighbor_entry->used = jiffies;
517 if (neighbor_entry->nud_state & NUD_VALID)
518 {
519 memcpy(haddr, neighbor_entry->ha, dev->addr_len);
520 return 1;
521 }
522 }
523 return 0;
524 }
525
526 static void DumpData(char *msg, struct strip *strip_info, __u8 *ptr, __u8 *end)
527 {
528 static const int MAX_DumpData = 80;
529 __u8 pkt_text[MAX_DumpData], *p = pkt_text;
530
531 *p++ = '\"';
532
533 while (ptr<end && p < &pkt_text[MAX_DumpData-4])
534 {
535 if (*ptr == '\\')
536 {
537 *p++ = '\\';
538 *p++ = '\\';
539 }
540 else
541 {
542 if (*ptr >= 32 && *ptr <= 126)
543 {
544 *p++ = *ptr;
545 }
546 else
547 {
548 sprintf(p, "\\%02X", *ptr);
549 p+= 3;
550 }
551 }
552 ptr++;
553 }
554
555 if (ptr == end)
556 {
557 *p++ = '\"';
558 }
559
560 *p++ = 0;
561
562 printk(KERN_INFO "%s: %-13s%s\n", strip_info->dev.name, msg, pkt_text);
563 }
564
565 #if 0
566 static void HexDump(char *msg, struct strip *strip_info, __u8 *start, __u8 *end)
567 {
568 __u8 *ptr = start;
569 printk(KERN_INFO "%s: %s: %d bytes\n", strip_info->dev.name, msg, end-ptr);
570
571 while (ptr < end)
572 {
573 long offset = ptr - start;
574 __u8 text[80], *p = text;
575 while (ptr < end && p < &text[16*3])
576 {
577 *p++ = hextable[*ptr >> 4];
578 *p++ = hextable[*ptr++ & 0xF];
579 *p++ = ' ';
580 }
581 p[-1] = 0;
582 printk(KERN_INFO "%s: %4lX %s\n", strip_info->dev.name, offset, text);
583 }
584 }
585 #endif
586
587
588 /************************************************************************/
589 /* Byte stuffing/unstuffing routines */
590
591 /* Stuffing scheme:
592 * 00 Unused (reserved character)
593 * 01-3F Run of 2-64 different characters
594 * 40-7F Run of 1-64 different characters plus a single zero at the end
595 * 80-BF Run of 1-64 of the same character
596 * C0-FF Run of 1-64 zeroes (ASCII 0)
597 */
598
599 typedef enum
600 {
601 Stuff_Diff = 0x00,
602 Stuff_DiffZero = 0x40,
603 Stuff_Same = 0x80,
604 Stuff_Zero = 0xC0,
605 Stuff_NoCode = 0xFF, /* Special code, meaning no code selected */
606
607 Stuff_CodeMask = 0xC0,
608 Stuff_CountMask = 0x3F,
609 Stuff_MaxCount = 0x3F,
610 Stuff_Magic = 0x0D /* The value we are eliminating */
611 } StuffingCode;
612
613 /* StuffData encodes the data starting at "src" for "length" bytes.
614 * It writes it to the buffer pointed to by "dst" (which must be at least
615 * as long as 1 + 65/64 of the input length). The output may be up to 1.6%
616 * larger than the input for pathological input, but will usually be smaller.
617 * StuffData returns the new value of the dst pointer as its result.
618 * "code_ptr_ptr" points to a "__u8 *" which is used to hold encoding state
619 * between calls, allowing an encoded packet to be incrementally built up
620 * from small parts. On the first call, the "__u8 *" pointed to should be
621 * initialized to NULL; between subsequent calls the calling routine should
622 * leave the value alone and simply pass it back unchanged so that the
623 * encoder can recover its current state.
624 */
625
626 #define StuffData_FinishBlock(X) \
627 (*code_ptr = (X) ^ Stuff_Magic, code = Stuff_NoCode)
628
629 static __u8 *StuffData(__u8 *src, __u32 length, __u8 *dst, __u8 **code_ptr_ptr)
630 {
631 __u8 *end = src + length;
632 __u8 *code_ptr = *code_ptr_ptr;
633 __u8 code = Stuff_NoCode, count = 0;
634
635 if (!length)
636 return(dst);
637
638 if (code_ptr)
639 {
640 /*
641 * Recover state from last call, if applicable
642 */
643 code = (*code_ptr ^ Stuff_Magic) & Stuff_CodeMask;
644 count = (*code_ptr ^ Stuff_Magic) & Stuff_CountMask;
645 }
646
647 while (src < end)
648 {
649 switch (code)
650 {
651 /* Stuff_NoCode: If no current code, select one */
652 case Stuff_NoCode:
653 /* Record where we're going to put this code */
654 code_ptr = dst++;
655 count = 0; /* Reset the count (zero means one instance) */
656 /* Tentatively start a new block */
657 if (*src == 0)
658 {
659 code = Stuff_Zero;
660 src++;
661 }
662 else
663 {
664 code = Stuff_Same;
665 *dst++ = *src++ ^ Stuff_Magic;
666 }
667 /* Note: We optimistically assume run of same -- */
668 /* which will be fixed later in Stuff_Same */
669 /* if it turns out not to be true. */
670 break;
671
672 /* Stuff_Zero: We already have at least one zero encoded */
673 case Stuff_Zero:
674 /* If another zero, count it, else finish this code block */
675 if (*src == 0)
676 {
677 count++;
678 src++;
679 }
680 else
681 {
682 StuffData_FinishBlock(Stuff_Zero + count);
683 }
684 break;
685
686 /* Stuff_Same: We already have at least one byte encoded */
687 case Stuff_Same:
688 /* If another one the same, count it */
689 if ((*src ^ Stuff_Magic) == code_ptr[1])
690 {
691 count++;
692 src++;
693 break;
694 }
695 /* else, this byte does not match this block. */
696 /* If we already have two or more bytes encoded, finish this code block */
697 if (count)
698 {
699 StuffData_FinishBlock(Stuff_Same + count);
700 break;
701 }
702 /* else, we only have one so far, so switch to Stuff_Diff code */
703 code = Stuff_Diff;
704 /* and fall through to Stuff_Diff case below
705 * Note cunning cleverness here: case Stuff_Diff compares
706 * the current character with the previous two to see if it
707 * has a run of three the same. Won't this be an error if
708 * there aren't two previous characters stored to compare with?
709 * No. Because we know the current character is *not* the same
710 * as the previous one, the first test below will necessarily
711 * fail and the send half of the "if" won't be executed.
712 */
713
714 /* Stuff_Diff: We have at least two *different* bytes encoded */
715 case Stuff_Diff:
716 /* If this is a zero, must encode a Stuff_DiffZero, and begin a new block */
717 if (*src == 0)
718 {
719 StuffData_FinishBlock(Stuff_DiffZero + count);
720 }
721 /* else, if we have three in a row, it is worth starting a Stuff_Same block */
722 else if ((*src ^ Stuff_Magic)==dst[-1] && dst[-1]==dst[-2])
723 {
724 /* Back off the last two characters we encoded */
725 code += count-2;
726 /* Note: "Stuff_Diff + 0" is an illegal code */
727 if (code == Stuff_Diff + 0)
728 {
729 code = Stuff_Same + 0;
730 }
731 StuffData_FinishBlock(code);
732 code_ptr = dst-2;
733 /* dst[-1] already holds the correct value */
734 count = 2; /* 2 means three bytes encoded */
735 code = Stuff_Same;
736 }
737 /* else, another different byte, so add it to the block */
738 else
739 {
740 *dst++ = *src ^ Stuff_Magic;
741 count++;
742 }
743 src++; /* Consume the byte */
744 break;
745 }
746 if (count == Stuff_MaxCount)
747 {
748 StuffData_FinishBlock(code + count);
749 }
750 }
751 if (code == Stuff_NoCode)
752 {
753 *code_ptr_ptr = NULL;
754 }
755 else
756 {
757 *code_ptr_ptr = code_ptr;
758 StuffData_FinishBlock(code + count);
759 }
760 return(dst);
761 }
762
763 /*
764 * UnStuffData decodes the data at "src", up to (but not including) "end".
765 * It writes the decoded data into the buffer pointed to by "dst", up to a
766 * maximum of "dst_length", and returns the new value of "src" so that a
767 * follow-on call can read more data, continuing from where the first left off.
768 *
769 * There are three types of results:
770 * 1. The source data runs out before extracting "dst_length" bytes:
771 * UnStuffData returns NULL to indicate failure.
772 * 2. The source data produces exactly "dst_length" bytes:
773 * UnStuffData returns new_src = end to indicate that all bytes were consumed.
774 * 3. "dst_length" bytes are extracted, with more remaining.
775 * UnStuffData returns new_src < end to indicate that there are more bytes
776 * to be read.
777 *
778 * Note: The decoding may be destructive, in that it may alter the source
779 * data in the process of decoding it (this is necessary to allow a follow-on
780 * call to resume correctly).
781 */
782
783 static __u8 *UnStuffData(__u8 *src, __u8 *end, __u8 *dst, __u32 dst_length)
784 {
785 __u8 *dst_end = dst + dst_length;
786 /* Sanity check */
787 if (!src || !end || !dst || !dst_length)
788 return(NULL);
789 while (src < end && dst < dst_end)
790 {
791 int count = (*src ^ Stuff_Magic) & Stuff_CountMask;
792 switch ((*src ^ Stuff_Magic) & Stuff_CodeMask)
793 {
794 case Stuff_Diff:
795 if (src+1+count >= end)
796 return(NULL);
797 do
798 {
799 *dst++ = *++src ^ Stuff_Magic;
800 }
801 while(--count >= 0 && dst < dst_end);
802 if (count < 0)
803 src += 1;
804 else
805 {
806 if (count == 0)
807 *src = Stuff_Same ^ Stuff_Magic;
808 else
809 *src = (Stuff_Diff + count) ^ Stuff_Magic;
810 }
811 break;
812 case Stuff_DiffZero:
813 if (src+1+count >= end)
814 return(NULL);
815 do
816 {
817 *dst++ = *++src ^ Stuff_Magic;
818 }
819 while(--count >= 0 && dst < dst_end);
820 if (count < 0)
821 *src = Stuff_Zero ^ Stuff_Magic;
822 else
823 *src = (Stuff_DiffZero + count) ^ Stuff_Magic;
824 break;
825 case Stuff_Same:
826 if (src+1 >= end)
827 return(NULL);
828 do
829 {
830 *dst++ = src[1] ^ Stuff_Magic;
831 }
832 while(--count >= 0 && dst < dst_end);
833 if (count < 0)
834 src += 2;
835 else
836 *src = (Stuff_Same + count) ^ Stuff_Magic;
837 break;
838 case Stuff_Zero:
839 do
840 {
841 *dst++ = 0;
842 }
843 while(--count >= 0 && dst < dst_end);
844 if (count < 0)
845 src += 1;
846 else
847 *src = (Stuff_Zero + count) ^ Stuff_Magic;
848 break;
849 }
850 }
851 if (dst < dst_end)
852 return(NULL);
853 else
854 return(src);
855 }
856
857
858 /************************************************************************/
859 /* General routines for STRIP */
860
861 /*
862 * get_baud returns the current baud rate, as one of the constants defined in
863 * termbits.h
864 * If the user has issued a baud rate override using the 'setserial' command
865 * and the logical current rate is set to 38.4, then the true baud rate
866 * currently in effect (57.6 or 115.2) is returned.
867 */
868 static unsigned int get_baud(struct tty_struct *tty)
869 {
870 if (!tty || !tty->termios) return(0);
871 if ((tty->termios->c_cflag & CBAUD) == B38400 && tty->driver_data)
872 {
873 struct async_struct *info = (struct async_struct *)tty->driver_data;
874 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI ) return(B57600);
875 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) return(B115200);
876 }
877 return(tty->termios->c_cflag & CBAUD);
878 }
879
880 /*
881 * set_baud sets the baud rate to the rate defined by baudcode
882 * Note: The rate B38400 should be avoided, because the user may have
883 * issued a 'setserial' speed override to map that to a different speed.
884 * We could achieve a true rate of 38400 if we needed to by cancelling
885 * any user speed override that is in place, but that might annoy the
886 * user, so it is simplest to just avoid using 38400.
887 */
888 static void set_baud(struct tty_struct *tty, unsigned int baudcode)
889 {
890 struct termios old_termios = *(tty->termios);
891 tty->termios->c_cflag &= ~CBAUD; /* Clear the old baud setting */
892 tty->termios->c_cflag |= baudcode; /* Set the new baud setting */
893 tty->driver.set_termios(tty, &old_termios);
894 }
895
896 /*
897 * Convert a string to a Metricom Address.
898 */
899
900 #define IS_RADIO_ADDRESS(p) ( \
901 isdigit((p)[0]) && isdigit((p)[1]) && isdigit((p)[2]) && isdigit((p)[3]) && \
902 (p)[4] == '-' && \
903 isdigit((p)[5]) && isdigit((p)[6]) && isdigit((p)[7]) && isdigit((p)[8]) )
904
905 static int string_to_radio_address(MetricomAddress *addr, __u8 *p)
906 {
907 if (!IS_RADIO_ADDRESS(p)) return(1);
908 addr->c[0] = 0;
909 addr->c[1] = 0;
910 addr->c[2] = READHEX(p[0]) << 4 | READHEX(p[1]);
911 addr->c[3] = READHEX(p[2]) << 4 | READHEX(p[3]);
912 addr->c[4] = READHEX(p[5]) << 4 | READHEX(p[6]);
913 addr->c[5] = READHEX(p[7]) << 4 | READHEX(p[8]);
914 return(0);
915 }
916
917 /*
918 * Convert a Metricom Address to a string.
919 */
920
921 static __u8 *radio_address_to_string(const MetricomAddress *addr, MetricomAddressString *p)
922 {
923 sprintf(p->c, "%02X%02X-%02X%02X", addr->c[2], addr->c[3], addr->c[4], addr->c[5]);
924 return(p->c);
925 }
926
927 /*
928 * Note: Must make sure sx_size is big enough to receive a stuffed
929 * MAX_RECV_MTU packet. Additionally, we also want to ensure that it's
930 * big enough to receive a large radio neighbour list (currently 4K).
931 */
932
933 static int allocate_buffers(struct strip *strip_info)
934 {
935 struct net_device *dev = &strip_info->dev;
936 int sx_size = MAX(STRIP_ENCAP_SIZE(MAX_RECV_MTU), 4096);
937 int tx_size = STRIP_ENCAP_SIZE(dev->mtu) + MaxCommandStringLength;
938 __u8 *r = kmalloc(MAX_RECV_MTU, GFP_ATOMIC);
939 __u8 *s = kmalloc(sx_size, GFP_ATOMIC);
940 __u8 *t = kmalloc(tx_size, GFP_ATOMIC);
941 if (r && s && t)
942 {
943 strip_info->rx_buff = r;
944 strip_info->sx_buff = s;
945 strip_info->tx_buff = t;
946 strip_info->sx_size = sx_size;
947 strip_info->tx_size = tx_size;
948 strip_info->mtu = dev->mtu;
949 return(1);
950 }
951 if (r) kfree(r);
952 if (s) kfree(s);
953 if (t) kfree(t);
954 return(0);
955 }
956
957 /*
958 * MTU has been changed by the IP layer. Unfortunately we are not told
959 * about this, but we spot it ourselves and fix things up. We could be in
960 * an upcall from the tty driver, or in an ip packet queue.
961 */
962
963 static void strip_changedmtu(struct strip *strip_info)
964 {
965 int old_mtu = strip_info->mtu;
966 struct net_device *dev = &strip_info->dev;
967 unsigned char *orbuff = strip_info->rx_buff;
968 unsigned char *osbuff = strip_info->sx_buff;
969 unsigned char *otbuff = strip_info->tx_buff;
970 InterruptStatus intstat;
971
972 if (dev->mtu > MAX_SEND_MTU)
973 {
974 printk(KERN_ERR "%s: MTU exceeds maximum allowable (%d), MTU change cancelled.\n",
975 strip_info->dev.name, MAX_SEND_MTU);
976 dev->mtu = old_mtu;
977 return;
978 }
979
980 /*
981 * Have to disable interrupts here because we're reallocating and resizing
982 * the serial buffers, and we can't have data arriving in them while we're
983 * moving them around in memory. This may cause data to be lost on the serial
984 * port, but hopefully people won't change MTU that often.
985 * Also note, this may not work on a symmetric multi-processor system.
986 */
987 intstat = DisableInterrupts();
988
989 if (!allocate_buffers(strip_info))
990 {
991 RestoreInterrupts(intstat);
992 printk(KERN_ERR "%s: unable to grow strip buffers, MTU change cancelled.\n",
993 strip_info->dev.name);
994 dev->mtu = old_mtu;
995 return;
996 }
997
998 if (strip_info->sx_count)
999 {
1000 if (strip_info->sx_count <= strip_info->sx_size)
1001 memcpy(strip_info->sx_buff, osbuff, strip_info->sx_count);
1002 else
1003 {
1004 strip_info->discard = strip_info->sx_count;
1005 strip_info->rx_over_errors++;
1006 }
1007 }
1008
1009 if (strip_info->tx_left)
1010 {
1011 if (strip_info->tx_left <= strip_info->tx_size)
1012 memcpy(strip_info->tx_buff, strip_info->tx_head, strip_info->tx_left);
1013 else
1014 {
1015 strip_info->tx_left = 0;
1016 strip_info->tx_dropped++;
1017 }
1018 }
1019 strip_info->tx_head = strip_info->tx_buff;
1020
1021 RestoreInterrupts(intstat);
1022
1023 printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
1024 strip_info->dev.name, old_mtu, strip_info->mtu);
1025
1026 if (orbuff) kfree(orbuff);
1027 if (osbuff) kfree(osbuff);
1028 if (otbuff) kfree(otbuff);
1029 }
1030
1031 static void strip_unlock(struct strip *strip_info)
1032 {
1033 /*
1034 * Set the timer to go off in one second.
1035 */
1036 strip_info->idle_timer.expires = jiffies + 1*HZ;
1037 add_timer(&strip_info->idle_timer);
1038 netif_wake_queue(&strip_info->dev);
1039 }
1040
1041
1042 /************************************************************************/
1043 /* Callback routines for exporting information through /proc */
1044
1045 /*
1046 * This function updates the total amount of data printed so far. It then
1047 * determines if the amount of data printed into a buffer has reached the
1048 * offset requested. If it hasn't, then the buffer is shifted over so that
1049 * the next bit of data can be printed over the old bit. If the total
1050 * amount printed so far exceeds the total amount requested, then this
1051 * function returns 1, otherwise 0.
1052 */
1053 static int
1054 shift_buffer(char *buffer, int requested_offset, int requested_len,
1055 int *total, int *slop, char **buf)
1056 {
1057 int printed;
1058
1059 /* printk(KERN_DEBUG "shift: buffer: %d o: %d l: %d t: %d buf: %d\n",
1060 (int) buffer, requested_offset, requested_len, *total,
1061 (int) *buf); */
1062 printed = *buf - buffer;
1063 if (*total + printed <= requested_offset) {
1064 *total += printed;
1065 *buf = buffer;
1066 }
1067 else {
1068 if (*total < requested_offset) {
1069 *slop = requested_offset - *total;
1070 }
1071 *total = requested_offset + printed - *slop;
1072 }
1073 if (*total > requested_offset + requested_len) {
1074 return 1;
1075 }
1076 else {
1077 return 0;
1078 }
1079 }
1080
1081 /*
1082 * This function calculates the actual start of the requested data
1083 * in the buffer. It also calculates actual length of data returned,
1084 * which could be less that the amount of data requested.
1085 */
1086 static int
1087 calc_start_len(char *buffer, char **start, int requested_offset,
1088 int requested_len, int total, char *buf)
1089 {
1090 int return_len, buffer_len;
1091
1092 buffer_len = buf - buffer;
1093 if (buffer_len >= 4095) {
1094 printk(KERN_ERR "STRIP: exceeded /proc buffer size\n");
1095 }
1096
1097 /*
1098 * There may be bytes before and after the
1099 * chunk that was actually requested.
1100 */
1101 return_len = total - requested_offset;
1102 if (return_len < 0) {
1103 return_len = 0;
1104 }
1105 *start = buf - return_len;
1106 if (return_len > requested_len) {
1107 return_len = requested_len;
1108 }
1109 /* printk(KERN_DEBUG "return_len: %d\n", return_len); */
1110 return return_len;
1111 }
1112
1113 /*
1114 * If the time is in the near future, time_delta prints the number of
1115 * seconds to go into the buffer and returns the address of the buffer.
1116 * If the time is not in the near future, it returns the address of the
1117 * string "Not scheduled" The buffer must be long enough to contain the
1118 * ascii representation of the number plus 9 charactes for the " seconds"
1119 * and the null character.
1120 */
1121 static char *time_delta(char buffer[], long time)
1122 {
1123 time -= jiffies;
1124 if (time > LongTime / 2) return("Not scheduled");
1125 if(time < 0) time = 0; /* Don't print negative times */
1126 sprintf(buffer, "%ld seconds", time / HZ);
1127 return(buffer);
1128 }
1129
1130 static int sprintf_neighbours(char *buffer, MetricomNodeTable *table, char *title)
1131 {
1132 /* We wrap this in a do/while loop, so if the table changes */
1133 /* while we're reading it, we just go around and try again. */
1134 struct timeval t;
1135 char *ptr;
1136 do
1137 {
1138 int i;
1139 t = table->timestamp;
1140 ptr = buffer;
1141 if (table->num_nodes) ptr += sprintf(ptr, "\n %s\n", title);
1142 for (i=0; i<table->num_nodes; i++)
1143 {
1144 InterruptStatus intstat = DisableInterrupts();
1145 MetricomNode node = table->node[i];
1146 RestoreInterrupts(intstat);
1147 ptr += sprintf(ptr, " %s\n", node.c);
1148 }
1149 } while (table->timestamp.tv_sec != t.tv_sec || table->timestamp.tv_usec != t.tv_usec);
1150 return ptr - buffer;
1151 }
1152
1153 /*
1154 * This function prints radio status information into the specified buffer.
1155 * I think the buffer size is 4K, so this routine should never print more
1156 * than 4K of data into it. With the maximum of 32 portables and 32 poletops
1157 * reported, the routine outputs 3107 bytes into the buffer.
1158 */
1159 static int
1160 sprintf_status_info(char *buffer, struct strip *strip_info)
1161 {
1162 char temp[32];
1163 char *p = buffer;
1164 MetricomAddressString addr_string;
1165
1166 /* First, we must copy all of our data to a safe place, */
1167 /* in case a serial interrupt comes in and changes it. */
1168 InterruptStatus intstat = DisableInterrupts();
1169 int tx_left = strip_info->tx_left;
1170 unsigned long rx_average_pps = strip_info->rx_average_pps;
1171 unsigned long tx_average_pps = strip_info->tx_average_pps;
1172 unsigned long sx_average_pps = strip_info->sx_average_pps;
1173 int working = strip_info->working;
1174 int firmware_level = strip_info->firmware_level;
1175 long watchdog_doprobe = strip_info->watchdog_doprobe;
1176 long watchdog_doreset = strip_info->watchdog_doreset;
1177 long gratuitous_arp = strip_info->gratuitous_arp;
1178 long arp_interval = strip_info->arp_interval;
1179 FirmwareVersion firmware_version = strip_info->firmware_version;
1180 SerialNumber serial_number = strip_info->serial_number;
1181 BatteryVoltage battery_voltage = strip_info->battery_voltage;
1182 char* if_name = strip_info->dev.name;
1183 MetricomAddress true_dev_addr = strip_info->true_dev_addr;
1184 MetricomAddress dev_dev_addr = *(MetricomAddress*)strip_info->dev.dev_addr;
1185 int manual_dev_addr = strip_info->manual_dev_addr;
1186 #ifdef EXT_COUNTERS
1187 unsigned long rx_bytes = strip_info->rx_bytes;
1188 unsigned long tx_bytes = strip_info->tx_bytes;
1189 unsigned long rx_rbytes = strip_info->rx_rbytes;
1190 unsigned long tx_rbytes = strip_info->tx_rbytes;
1191 unsigned long rx_sbytes = strip_info->rx_sbytes;
1192 unsigned long tx_sbytes = strip_info->tx_sbytes;
1193 unsigned long rx_ebytes = strip_info->rx_ebytes;
1194 unsigned long tx_ebytes = strip_info->tx_ebytes;
1195 #endif
1196 RestoreInterrupts(intstat);
1197
1198 p += sprintf(p, "\nInterface name\t\t%s\n", if_name);
1199 p += sprintf(p, " Radio working:\t\t%s\n", working ? "Yes" : "No");
1200 radio_address_to_string(&true_dev_addr, &addr_string);
1201 p += sprintf(p, " Radio address:\t\t%s\n", addr_string.c);
1202 if (manual_dev_addr)
1203 {
1204 radio_address_to_string(&dev_dev_addr, &addr_string);
1205 p += sprintf(p, " Device address:\t%s\n", addr_string.c);
1206 }
1207 p += sprintf(p, " Firmware version:\t%s", !working ? "Unknown" :
1208 !firmware_level ? "Should be upgraded" :
1209 firmware_version.c);
1210 if (firmware_level >= ChecksummedMessages) p += sprintf(p, " (Checksums Enabled)");
1211 p += sprintf(p, "\n");
1212 p += sprintf(p, " Serial number:\t\t%s\n", serial_number.c);
1213 p += sprintf(p, " Battery voltage:\t%s\n", battery_voltage.c);
1214 p += sprintf(p, " Transmit queue (bytes):%d\n", tx_left);
1215 p += sprintf(p, " Receive packet rate: %ld packets per second\n", rx_average_pps / 8);
1216 p += sprintf(p, " Transmit packet rate: %ld packets per second\n", tx_average_pps / 8);
1217 p += sprintf(p, " Sent packet rate: %ld packets per second\n", sx_average_pps / 8);
1218 p += sprintf(p, " Next watchdog probe:\t%s\n", time_delta(temp, watchdog_doprobe));
1219 p += sprintf(p, " Next watchdog reset:\t%s\n", time_delta(temp, watchdog_doreset));
1220 p += sprintf(p, " Next gratuitous ARP:\t");
1221
1222 if (!memcmp(strip_info->dev.dev_addr, zero_address.c, sizeof(zero_address)))
1223 p += sprintf(p, "Disabled\n");
1224 else
1225 {
1226 p += sprintf(p, "%s\n", time_delta(temp, gratuitous_arp));
1227 p += sprintf(p, " Next ARP interval:\t%ld seconds\n", JIFFIE_TO_SEC(arp_interval));
1228 }
1229
1230 if (working)
1231 {
1232 #ifdef EXT_COUNTERS
1233 p += sprintf(p, "\n");
1234 p += sprintf(p, " Total bytes: \trx:\t%lu\ttx:\t%lu\n", rx_bytes, tx_bytes);
1235 p += sprintf(p, " thru radio: \trx:\t%lu\ttx:\t%lu\n", rx_rbytes, tx_rbytes);
1236 p += sprintf(p, " thru serial port: \trx:\t%lu\ttx:\t%lu\n", rx_sbytes, tx_sbytes);
1237 p += sprintf(p, " Total stat/err bytes:\trx:\t%lu\ttx:\t%lu\n", rx_ebytes, tx_ebytes);
1238 #endif
1239 p += sprintf_neighbours(p, &strip_info->poletops, "Poletops:");
1240 p += sprintf_neighbours(p, &strip_info->portables, "Portables:");
1241 }
1242
1243 return p - buffer;
1244 }
1245
1246 /*
1247 * This function is exports status information from the STRIP driver through
1248 * the /proc file system.
1249 */
1250
1251 static int get_status_info(char *buffer, char **start, off_t req_offset, int req_len)
1252 {
1253 int total = 0, slop = 0;
1254 struct strip *strip_info = struct_strip_list;
1255 char *buf = buffer;
1256
1257 buf += sprintf(buf, "strip_version: %s\n", StripVersion);
1258 if (shift_buffer(buffer, req_offset, req_len, &total, &slop, &buf)) goto exit;
1259
1260 while (strip_info != NULL)
1261 {
1262 buf += sprintf_status_info(buf, strip_info);
1263 if (shift_buffer(buffer, req_offset, req_len, &total, &slop, &buf)) break;
1264 strip_info = strip_info->next;
1265 }
1266 exit:
1267 return(calc_start_len(buffer, start, req_offset, req_len, total, buf));
1268 }
1269
1270 /************************************************************************/
1271 /* Sending routines */
1272
1273 static void ResetRadio(struct strip *strip_info)
1274 {
1275 struct tty_struct *tty = strip_info->tty;
1276 static const char init[] = "ate0q1dt**starmode\r**";
1277 StringDescriptor s = { init, sizeof(init)-1 };
1278
1279 /*
1280 * If the radio isn't working anymore,
1281 * we should clear the old status information.
1282 */
1283 if (strip_info->working)
1284 {
1285 printk(KERN_INFO "%s: No response: Resetting radio.\n", strip_info->dev.name);
1286 strip_info->firmware_version.c[0] = '\0';
1287 strip_info->serial_number.c[0] = '\0';
1288 strip_info->battery_voltage.c[0] = '\0';
1289 strip_info->portables.num_nodes = 0;
1290 do_gettimeofday(&strip_info->portables.timestamp);
1291 strip_info->poletops.num_nodes = 0;
1292 do_gettimeofday(&strip_info->poletops.timestamp);
1293 }
1294
1295 strip_info->pps_timer = jiffies;
1296 strip_info->rx_pps_count = 0;
1297 strip_info->tx_pps_count = 0;
1298 strip_info->sx_pps_count = 0;
1299 strip_info->rx_average_pps = 0;
1300 strip_info->tx_average_pps = 0;
1301 strip_info->sx_average_pps = 0;
1302
1303 /* Mark radio address as unknown */
1304 *(MetricomAddress*)&strip_info->true_dev_addr = zero_address;
1305 if (!strip_info->manual_dev_addr)
1306 *(MetricomAddress*)strip_info->dev.dev_addr = zero_address;
1307 strip_info->working = FALSE;
1308 strip_info->firmware_level = NoStructure;
1309 strip_info->next_command = CompatibilityCommand;
1310 strip_info->watchdog_doprobe = jiffies + 10 * HZ;
1311 strip_info->watchdog_doreset = jiffies + 1 * HZ;
1312
1313 /* If the user has selected a baud rate above 38.4 see what magic we have to do */
1314 if (strip_info->user_baud > B38400)
1315 {
1316 /*
1317 * Subtle stuff: Pay attention :-)
1318 * If the serial port is currently at the user's selected (>38.4) rate,
1319 * then we temporarily switch to 19.2 and issue the ATS304 command
1320 * to tell the radio to switch to the user's selected rate.
1321 * If the serial port is not currently at that rate, that means we just
1322 * issued the ATS304 command last time through, so this time we restore
1323 * the user's selected rate and issue the normal starmode reset string.
1324 */
1325 if (strip_info->user_baud == get_baud(tty))
1326 {
1327 static const char b0[] = "ate0q1s304=57600\r";
1328 static const char b1[] = "ate0q1s304=115200\r";
1329 static const StringDescriptor baudstring[2] =
1330 { { b0, sizeof(b0)-1 }, { b1, sizeof(b1)-1 } };
1331 set_baud(tty, B19200);
1332 if (strip_info->user_baud == B57600 ) s = baudstring[0];
1333 else if (strip_info->user_baud == B115200) s = baudstring[1];
1334 else s = baudstring[1]; /* For now */
1335 }
1336 else set_baud(tty, strip_info->user_baud);
1337 }
1338
1339 tty->driver.write(tty, 0, s.string, s.length);
1340 #ifdef EXT_COUNTERS
1341 strip_info->tx_ebytes += s.length;
1342 #endif
1343 }
1344
1345 /*
1346 * Called by the driver when there's room for more data. If we have
1347 * more packets to send, we send them here.
1348 */
1349
1350 static void strip_write_some_more(struct tty_struct *tty)
1351 {
1352 struct strip *strip_info = (struct strip *) tty->disc_data;
1353
1354 /* First make sure we're connected. */
1355 if (!strip_info || strip_info->magic != STRIP_MAGIC ||
1356 !netif_running(&strip_info->dev))
1357 return;
1358
1359 if (strip_info->tx_left > 0)
1360 {
1361 /*
1362 * If some data left, send it
1363 * Note: There's a kernel design bug here. The write_wakeup routine has to
1364 * know how many bytes were written in the previous call, but the number of
1365 * bytes written is returned as the result of the tty->driver.write call,
1366 * and there's no guarantee that the tty->driver.write routine will have
1367 * returned before the write_wakeup routine is invoked. If the PC has fast
1368 * Serial DMA hardware, then it's quite possible that the write could complete
1369 * almost instantaneously, meaning that my write_wakeup routine could be
1370 * called immediately, before tty->driver.write has had a chance to return
1371 * the number of bytes that it wrote. In an attempt to guard against this,
1372 * I disable interrupts around the call to tty->driver.write, although even
1373 * this might not work on a symmetric multi-processor system.
1374 */
1375 InterruptStatus intstat = DisableInterrupts();
1376 int num_written = tty->driver.write(tty, 0, strip_info->tx_head, strip_info->tx_left);
1377 strip_info->tx_left -= num_written;
1378 strip_info->tx_head += num_written;
1379 #ifdef EXT_COUNTERS
1380 strip_info->tx_sbytes += num_written;
1381 #endif
1382 RestoreInterrupts(intstat);
1383 }
1384 else /* Else start transmission of another packet */
1385 {
1386 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1387 strip_unlock(strip_info);
1388 }
1389 }
1390
1391 static __u8 *add_checksum(__u8 *buffer, __u8 *end)
1392 {
1393 __u16 sum = 0;
1394 __u8 *p = buffer;
1395 while (p < end) sum += *p++;
1396 end[3] = hextable[sum & 0xF]; sum >>= 4;
1397 end[2] = hextable[sum & 0xF]; sum >>= 4;
1398 end[1] = hextable[sum & 0xF]; sum >>= 4;
1399 end[0] = hextable[sum & 0xF];
1400 return(end+4);
1401 }
1402
1403 static unsigned char *strip_make_packet(unsigned char *buffer, struct strip *strip_info, struct sk_buff *skb)
1404 {
1405 __u8 *ptr = buffer;
1406 __u8 *stuffstate = NULL;
1407 STRIP_Header *header = (STRIP_Header *)skb->data;
1408 MetricomAddress haddr = header->dst_addr;
1409 int len = skb->len - sizeof(STRIP_Header);
1410 MetricomKey key;
1411
1412 /*HexDump("strip_make_packet", strip_info, skb->data, skb->data + skb->len);*/
1413
1414 if (header->protocol == htons(ETH_P_IP)) key = SIP0Key;
1415 else if (header->protocol == htons(ETH_P_ARP)) key = ARP0Key;
1416 else
1417 {
1418 printk(KERN_ERR "%s: strip_make_packet: Unknown packet type 0x%04X\n",
1419 strip_info->dev.name, ntohs(header->protocol));
1420 return(NULL);
1421 }
1422
1423 if (len > strip_info->mtu)
1424 {
1425 printk(KERN_ERR "%s: Dropping oversized transmit packet: %d bytes\n",
1426 strip_info->dev.name, len);
1427 return(NULL);
1428 }
1429
1430 /*
1431 * If we're sending to ourselves, discard the packet.
1432 * (Metricom radios choke if they try to send a packet to their own address.)
1433 */
1434 if (!memcmp(haddr.c, strip_info->true_dev_addr.c, sizeof(haddr)))
1435 {
1436 printk(KERN_ERR "%s: Dropping packet addressed to self\n", strip_info->dev.name);
1437 return(NULL);
1438 }
1439
1440 /*
1441 * If this is a broadcast packet, send it to our designated Metricom
1442 * 'broadcast hub' radio (First byte of address being 0xFF means broadcast)
1443 */
1444 if (haddr.c[0] == 0xFF)
1445 {
1446 u32 brd = 0;
1447 struct in_device *in_dev = in_dev_get(&strip_info->dev);
1448 if (in_dev == NULL)
1449 return NULL;
1450 read_lock(&in_dev->lock);
1451 if (in_dev->ifa_list)
1452 brd = in_dev->ifa_list->ifa_broadcast;
1453 read_unlock(&in_dev->lock);
1454 in_dev_put(in_dev);
1455
1456 /* arp_query returns 1 if it succeeds in looking up the address, 0 if it fails */
1457 if (!arp_query(haddr.c, brd, &strip_info->dev))
1458 {
1459 printk(KERN_ERR "%s: Unable to send packet (no broadcast hub configured)\n",
1460 strip_info->dev.name);
1461 return(NULL);
1462 }
1463 /*
1464 * If we are the broadcast hub, don't bother sending to ourselves.
1465 * (Metricom radios choke if they try to send a packet to their own address.)
1466 */
1467 if (!memcmp(haddr.c, strip_info->true_dev_addr.c, sizeof(haddr))) return(NULL);
1468 }
1469
1470 *ptr++ = 0x0D;
1471 *ptr++ = '*';
1472 *ptr++ = hextable[haddr.c[2] >> 4];
1473 *ptr++ = hextable[haddr.c[2] & 0xF];
1474 *ptr++ = hextable[haddr.c[3] >> 4];
1475 *ptr++ = hextable[haddr.c[3] & 0xF];
1476 *ptr++ = '-';
1477 *ptr++ = hextable[haddr.c[4] >> 4];
1478 *ptr++ = hextable[haddr.c[4] & 0xF];
1479 *ptr++ = hextable[haddr.c[5] >> 4];
1480 *ptr++ = hextable[haddr.c[5] & 0xF];
1481 *ptr++ = '*';
1482 *ptr++ = key.c[0];
1483 *ptr++ = key.c[1];
1484 *ptr++ = key.c[2];
1485 *ptr++ = key.c[3];
1486
1487 ptr = StuffData(skb->data + sizeof(STRIP_Header), len, ptr, &stuffstate);
1488
1489 if (strip_info->firmware_level >= ChecksummedMessages) ptr = add_checksum(buffer+1, ptr);
1490
1491 *ptr++ = 0x0D;
1492 return(ptr);
1493 }
1494
1495 static void strip_send(struct strip *strip_info, struct sk_buff *skb)
1496 {
1497 MetricomAddress haddr;
1498 unsigned char *ptr = strip_info->tx_buff;
1499 int doreset = (long)jiffies - strip_info->watchdog_doreset >= 0;
1500 int doprobe = (long)jiffies - strip_info->watchdog_doprobe >= 0 && !doreset;
1501 u32 addr, brd;
1502
1503 /*
1504 * 1. If we have a packet, encapsulate it and put it in the buffer
1505 */
1506 if (skb)
1507 {
1508 char *newptr = strip_make_packet(ptr, strip_info, skb);
1509 strip_info->tx_pps_count++;
1510 if (!newptr) strip_info->tx_dropped++;
1511 else
1512 {
1513 ptr = newptr;
1514 strip_info->sx_pps_count++;
1515 strip_info->tx_packets++; /* Count another successful packet */
1516 #ifdef EXT_COUNTERS
1517 strip_info->tx_bytes += skb->len;
1518 strip_info->tx_rbytes += ptr - strip_info->tx_buff;
1519 #endif
1520 /*DumpData("Sending:", strip_info, strip_info->tx_buff, ptr);*/
1521 /*HexDump("Sending", strip_info, strip_info->tx_buff, ptr);*/
1522 }
1523 }
1524
1525 /*
1526 * 2. If it is time for another tickle, tack it on, after the packet
1527 */
1528 if (doprobe)
1529 {
1530 StringDescriptor ts = CommandString[strip_info->next_command];
1531 #if TICKLE_TIMERS
1532 {
1533 struct timeval tv;
1534 do_gettimeofday(&tv);
1535 printk(KERN_INFO "**** Sending tickle string %d at %02d.%06d\n",
1536 strip_info->next_command, tv.tv_sec % 100, tv.tv_usec);
1537 }
1538 #endif
1539 if (ptr == strip_info->tx_buff) *ptr++ = 0x0D;
1540
1541 *ptr++ = '*'; /* First send "**" to provoke an error message */
1542 *ptr++ = '*';
1543
1544 /* Then add the command */
1545 memcpy(ptr, ts.string, ts.length);
1546
1547 /* Add a checksum ? */
1548 if (strip_info->firmware_level < ChecksummedMessages) ptr += ts.length;
1549 else ptr = add_checksum(ptr, ptr + ts.length);
1550
1551 *ptr++ = 0x0D; /* Terminate the command with a <CR> */
1552
1553 /* Cycle to next periodic command? */
1554 if (strip_info->firmware_level >= StructuredMessages)
1555 if (++strip_info->next_command >= ELEMENTS_OF(CommandString))
1556 strip_info->next_command = 0;
1557 #ifdef EXT_COUNTERS
1558 strip_info->tx_ebytes += ts.length;
1559 #endif
1560 strip_info->watchdog_doprobe = jiffies + 10 * HZ;
1561 strip_info->watchdog_doreset = jiffies + 1 * HZ;
1562 /*printk(KERN_INFO "%s: Routine radio test.\n", strip_info->dev.name);*/
1563 }
1564
1565 /*
1566 * 3. Set up the strip_info ready to send the data (if any).
1567 */
1568 strip_info->tx_head = strip_info->tx_buff;
1569 strip_info->tx_left = ptr - strip_info->tx_buff;
1570 strip_info->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1571
1572 /*
1573 * 4. Debugging check to make sure we're not overflowing the buffer.
1574 */
1575 if (strip_info->tx_size - strip_info->tx_left < 20)
1576 printk(KERN_ERR "%s: Sending%5d bytes;%5d bytes free.\n", strip_info->dev.name,
1577 strip_info->tx_left, strip_info->tx_size - strip_info->tx_left);
1578
1579 /*
1580 * 5. If watchdog has expired, reset the radio. Note: if there's data waiting in
1581 * the buffer, strip_write_some_more will send it after the reset has finished
1582 */
1583 if (doreset) { ResetRadio(strip_info); return; }
1584
1585 if (1) {
1586 struct in_device *in_dev = in_dev_get(&strip_info->dev);
1587 brd = addr = 0;
1588 if (in_dev) {
1589 read_lock(&in_dev->lock);
1590 if (in_dev->ifa_list) {
1591 brd = in_dev->ifa_list->ifa_broadcast;
1592 addr = in_dev->ifa_list->ifa_local;
1593 }
1594 read_unlock(&in_dev->lock);
1595 in_dev_put(in_dev);
1596 }
1597 }
1598
1599
1600 /*
1601 * 6. If it is time for a periodic ARP, queue one up to be sent.
1602 * We only do this if:
1603 * 1. The radio is working
1604 * 2. It's time to send another periodic ARP
1605 * 3. We really know what our address is (and it is not manually set to zero)
1606 * 4. We have a designated broadcast address configured
1607 * If we queue up an ARP packet when we don't have a designated broadcast
1608 * address configured, then the packet will just have to be discarded in
1609 * strip_make_packet. This is not fatal, but it causes misleading information
1610 * to be displayed in tcpdump. tcpdump will report that periodic APRs are
1611 * being sent, when in fact they are not, because they are all being dropped
1612 * in the strip_make_packet routine.
1613 */
1614 if (strip_info->working && (long)jiffies - strip_info->gratuitous_arp >= 0 &&
1615 memcmp(strip_info->dev.dev_addr, zero_address.c, sizeof(zero_address)) &&
1616 arp_query(haddr.c, brd, &strip_info->dev))
1617 {
1618 /*printk(KERN_INFO "%s: Sending gratuitous ARP with interval %ld\n",
1619 strip_info->dev.name, strip_info->arp_interval / HZ);*/
1620 strip_info->gratuitous_arp = jiffies + strip_info->arp_interval;
1621 strip_info->arp_interval *= 2;
1622 if (strip_info->arp_interval > MaxARPInterval)
1623 strip_info->arp_interval = MaxARPInterval;
1624 if (addr)
1625 arp_send(
1626 ARPOP_REPLY, ETH_P_ARP,
1627 addr, /* Target address of ARP packet is our address */
1628 &strip_info->dev, /* Device to send packet on */
1629 addr, /* Source IP address this ARP packet comes from */
1630 NULL, /* Destination HW address is NULL (broadcast it) */
1631 strip_info->dev.dev_addr, /* Source HW address is our HW address */
1632 strip_info->dev.dev_addr); /* Target HW address is our HW address (redundant) */
1633 }
1634
1635 /*
1636 * 7. All ready. Start the transmission
1637 */
1638 strip_write_some_more(strip_info->tty);
1639 }
1640
1641 /* Encapsulate a datagram and kick it into a TTY queue. */
1642 static int strip_xmit(struct sk_buff *skb, struct net_device *dev)
1643 {
1644 struct strip *strip_info = (struct strip *)(dev->priv);
1645
1646 if (!netif_running(dev))
1647 {
1648 printk(KERN_ERR "%s: xmit call when iface is down\n", dev->name);
1649 return(1);
1650 }
1651
1652 netif_stop_queue(dev);
1653
1654 del_timer(&strip_info->idle_timer);
1655
1656 /* See if someone has been ifconfigging */
1657 if (strip_info->mtu != strip_info->dev.mtu)
1658 strip_changedmtu(strip_info);
1659
1660 if (jiffies - strip_info->pps_timer > HZ)
1661 {
1662 unsigned long t = jiffies - strip_info->pps_timer;
1663 unsigned long rx_pps_count = (strip_info->rx_pps_count * HZ * 8 + t/2) / t;
1664 unsigned long tx_pps_count = (strip_info->tx_pps_count * HZ * 8 + t/2) / t;
1665 unsigned long sx_pps_count = (strip_info->sx_pps_count * HZ * 8 + t/2) / t;
1666
1667 strip_info->pps_timer = jiffies;
1668 strip_info->rx_pps_count = 0;
1669 strip_info->tx_pps_count = 0;
1670 strip_info->sx_pps_count = 0;
1671
1672 strip_info->rx_average_pps = (strip_info->rx_average_pps + rx_pps_count + 1) / 2;
1673 strip_info->tx_average_pps = (strip_info->tx_average_pps + tx_pps_count + 1) / 2;
1674 strip_info->sx_average_pps = (strip_info->sx_average_pps + sx_pps_count + 1) / 2;
1675
1676 if (rx_pps_count / 8 >= 10)
1677 printk(KERN_INFO "%s: WARNING: Receiving %ld packets per second.\n",
1678 strip_info->dev.name, rx_pps_count / 8);
1679 if (tx_pps_count / 8 >= 10)
1680 printk(KERN_INFO "%s: WARNING: Tx %ld packets per second.\n",
1681 strip_info->dev.name, tx_pps_count / 8);
1682 if (sx_pps_count / 8 >= 10)
1683 printk(KERN_INFO "%s: WARNING: Sending %ld packets per second.\n",
1684 strip_info->dev.name, sx_pps_count / 8);
1685 }
1686
1687 strip_send(strip_info, skb);
1688
1689 if (skb)
1690 dev_kfree_skb(skb);
1691 return(0);
1692 }
1693
1694 /*
1695 * IdleTask periodically calls strip_xmit, so even when we have no IP packets
1696 * to send for an extended period of time, the watchdog processing still gets
1697 * done to ensure that the radio stays in Starmode
1698 */
1699
1700 static void strip_IdleTask(unsigned long parameter)
1701 {
1702 strip_xmit(NULL, (struct net_device *)parameter);
1703 }
1704
1705 /*
1706 * Create the MAC header for an arbitrary protocol layer
1707 *
1708 * saddr!=NULL means use this specific address (n/a for Metricom)
1709 * saddr==NULL means use default device source address
1710 * daddr!=NULL means use this destination address
1711 * daddr==NULL means leave destination address alone
1712 * (e.g. unresolved arp -- kernel will call
1713 * rebuild_header later to fill in the address)
1714 */
1715
1716 static int strip_header(struct sk_buff *skb, struct net_device *dev,
1717 unsigned short type, void *daddr, void *saddr, unsigned len)
1718 {
1719 struct strip *strip_info = (struct strip *)(dev->priv);
1720 STRIP_Header *header = (STRIP_Header *)skb_push(skb, sizeof(STRIP_Header));
1721
1722 /*printk(KERN_INFO "%s: strip_header 0x%04X %s\n", dev->name, type,
1723 type == ETH_P_IP ? "IP" : type == ETH_P_ARP ? "ARP" : "");*/
1724
1725 header->src_addr = strip_info->true_dev_addr;
1726 header->protocol = htons(type);
1727
1728 /*HexDump("strip_header", (struct strip *)(dev->priv), skb->data, skb->data + skb->len);*/
1729
1730 if (!daddr) return(-dev->hard_header_len);
1731
1732 header->dst_addr = *(MetricomAddress*)daddr;
1733 return(dev->hard_header_len);
1734 }
1735
1736 /*
1737 * Rebuild the MAC header. This is called after an ARP
1738 * (or in future other address resolution) has completed on this
1739 * sk_buff. We now let ARP fill in the other fields.
1740 * I think this should return zero if packet is ready to send,
1741 * or non-zero if it needs more time to do an address lookup
1742 */
1743
1744 static int strip_rebuild_header(struct sk_buff *skb)
1745 {
1746 #ifdef CONFIG_INET
1747 STRIP_Header *header = (STRIP_Header *) skb->data;
1748
1749 /* Arp find returns zero if if knows the address, */
1750 /* or if it doesn't know the address it sends an ARP packet and returns non-zero */
1751 return arp_find(header->dst_addr.c, skb)? 1 : 0;
1752 #else
1753 return 0;
1754 #endif
1755 }
1756
1757
1758 /************************************************************************/
1759 /* Receiving routines */
1760
1761 static int strip_receive_room(struct tty_struct *tty)
1762 {
1763 return 0x10000; /* We can handle an infinite amount of data. :-) */
1764 }
1765
1766 /*
1767 * This function parses the response to the ATS300? command,
1768 * extracting the radio version and serial number.
1769 */
1770 static void get_radio_version(struct strip *strip_info, __u8 *ptr, __u8 *end)
1771 {
1772 __u8 *p, *value_begin, *value_end;
1773 int len;
1774
1775 /* Determine the beginning of the second line of the payload */
1776 p = ptr;
1777 while (p < end && *p != 10) p++;
1778 if (p >= end) return;
1779 p++;
1780 value_begin = p;
1781
1782 /* Determine the end of line */
1783 while (p < end && *p != 10) p++;
1784 if (p >= end) return;
1785 value_end = p;
1786 p++;
1787
1788 len = value_end - value_begin;
1789 len = MIN(len, sizeof(FirmwareVersion) - 1);
1790 if (strip_info->firmware_version.c[0] == 0)
1791 printk(KERN_INFO "%s: Radio Firmware: %.*s\n",
1792 strip_info->dev.name, len, value_begin);
1793 sprintf(strip_info->firmware_version.c, "%.*s", len, value_begin);
1794
1795 /* Look for the first colon */
1796 while (p < end && *p != ':') p++;
1797 if (p >= end) return;
1798 /* Skip over the space */
1799 p += 2;
1800 len = sizeof(SerialNumber) - 1;
1801 if (p + len <= end) {
1802 sprintf(strip_info->serial_number.c, "%.*s", len, p);
1803 }
1804 else {
1805 printk(KERN_DEBUG "STRIP: radio serial number shorter (%d) than expected (%d)\n",
1806 end - p, len);
1807 }
1808 }
1809
1810 /*
1811 * This function parses the response to the ATS325? command,
1812 * extracting the radio battery voltage.
1813 */
1814 static void get_radio_voltage(struct strip *strip_info, __u8 *ptr, __u8 *end)
1815 {
1816 int len;
1817
1818 len = sizeof(BatteryVoltage) - 1;
1819 if (ptr + len <= end) {
1820 sprintf(strip_info->battery_voltage.c, "%.*s", len, ptr);
1821 }
1822 else {
1823 printk(KERN_DEBUG "STRIP: radio voltage string shorter (%d) than expected (%d)\n",
1824 end - ptr, len);
1825 }
1826 }
1827
1828 /*
1829 * This function parses the responses to the AT~LA and ATS311 commands,
1830 * which list the radio's neighbours.
1831 */
1832 static void get_radio_neighbours(MetricomNodeTable *table, __u8 *ptr, __u8 *end)
1833 {
1834 table->num_nodes = 0;
1835 while (ptr < end && table->num_nodes < NODE_TABLE_SIZE)
1836 {
1837 MetricomNode *node = &table->node[table->num_nodes++];
1838 char *dst = node->c, *limit = dst + sizeof(*node) - 1;
1839 while (ptr < end && *ptr <= 32) ptr++;
1840 while (ptr < end && dst < limit && *ptr != 10) *dst++ = *ptr++;
1841 *dst++ = 0;
1842 while (ptr < end && ptr[-1] != 10) ptr++;
1843 }
1844 do_gettimeofday(&table->timestamp);
1845 }
1846
1847 static int get_radio_address(struct strip *strip_info, __u8 *p)
1848 {
1849 MetricomAddress addr;
1850
1851 if (string_to_radio_address(&addr, p)) return(1);
1852
1853 /* See if our radio address has changed */
1854 if (memcmp(strip_info->true_dev_addr.c, addr.c, sizeof(addr)))
1855 {
1856 MetricomAddressString addr_string;
1857 radio_address_to_string(&addr, &addr_string);
1858 printk(KERN_INFO "%s: Radio address = %s\n", strip_info->dev.name, addr_string.c);
1859 strip_info->true_dev_addr = addr;
1860 if (!strip_info->manual_dev_addr) *(MetricomAddress*)strip_info->dev.dev_addr = addr;
1861 /* Give the radio a few seconds to get its head straight, then send an arp */
1862 strip_info->gratuitous_arp = jiffies + 15 * HZ;
1863 strip_info->arp_interval = 1 * HZ;
1864 }
1865 return(0);
1866 }
1867
1868 static int verify_checksum(struct strip *strip_info)
1869 {
1870 __u8 *p = strip_info->sx_buff;
1871 __u8 *end = strip_info->sx_buff + strip_info->sx_count - 4;
1872 u_short sum = (READHEX16(end[0]) << 12) | (READHEX16(end[1]) << 8) |
1873 (READHEX16(end[2]) << 4) | (READHEX16(end[3]));
1874 while (p < end) sum -= *p++;
1875 if (sum == 0 && strip_info->firmware_level == StructuredMessages)
1876 {
1877 strip_info->firmware_level = ChecksummedMessages;
1878 printk(KERN_INFO "%s: Radio provides message checksums\n", strip_info->dev.name);
1879 }
1880 return(sum == 0);
1881 }
1882
1883 static void RecvErr(char *msg, struct strip *strip_info)
1884 {
1885 __u8 *ptr = strip_info->sx_buff;
1886 __u8 *end = strip_info->sx_buff + strip_info->sx_count;
1887 DumpData(msg, strip_info, ptr, end);
1888 strip_info->rx_errors++;
1889 }
1890
1891 static void RecvErr_Message(struct strip *strip_info, __u8 *sendername, const __u8 *msg, u_long len)
1892 {
1893 if (has_prefix(msg, len, "001")) /* Not in StarMode! */
1894 {
1895 RecvErr("Error Msg:", strip_info);
1896 printk(KERN_INFO "%s: Radio %s is not in StarMode\n",
1897 strip_info->dev.name, sendername);
1898 }
1899
1900 else if (has_prefix(msg, len, "002")) /* Remap handle */
1901 {
1902 /* We ignore "Remap handle" messages for now */
1903 }
1904
1905 else if (has_prefix(msg, len, "003")) /* Can't resolve name */
1906 {
1907 RecvErr("Error Msg:", strip_info);
1908 printk(KERN_INFO "%s: Destination radio name is unknown\n",
1909 strip_info->dev.name);
1910 }
1911
1912 else if (has_prefix(msg, len, "004")) /* Name too small or missing */
1913 {
1914 strip_info->watchdog_doreset = jiffies + LongTime;
1915 #if TICKLE_TIMERS
1916 {
1917 struct timeval tv;
1918 do_gettimeofday(&tv);
1919 printk(KERN_INFO "**** Got ERR_004 response at %02d.%06d\n",
1920 tv.tv_sec % 100, tv.tv_usec);
1921 }
1922 #endif
1923 if (!strip_info->working)
1924 {
1925 strip_info->working = TRUE;
1926 printk(KERN_INFO "%s: Radio now in starmode\n", strip_info->dev.name);
1927 /*
1928 * If the radio has just entered a working state, we should do our first
1929 * probe ASAP, so that we find out our radio address etc. without delay.
1930 */
1931 strip_info->watchdog_doprobe = jiffies;
1932 }
1933 if (strip_info->firmware_level == NoStructure && sendername)
1934 {
1935 strip_info->firmware_level = StructuredMessages;
1936 strip_info->next_command = 0; /* Try to enable checksums ASAP */
1937 printk(KERN_INFO "%s: Radio provides structured messages\n", strip_info->dev.name);
1938 }
1939 if (strip_info->firmware_level >= StructuredMessages)
1940 {
1941 /*
1942 * If this message has a valid checksum on the end, then the call to verify_checksum
1943 * will elevate the firmware_level to ChecksummedMessages for us. (The actual return
1944 * code from verify_checksum is ignored here.)
1945 */
1946 verify_checksum(strip_info);
1947 /*
1948 * If the radio has structured messages but we don't yet have all our information about it,
1949 * we should do probes without delay, until we have gathered all the information
1950 */
1951 if (!GOT_ALL_RADIO_INFO(strip_info)) strip_info->watchdog_doprobe = jiffies;
1952 }
1953 }
1954
1955 else if (has_prefix(msg, len, "005")) /* Bad count specification */
1956 RecvErr("Error Msg:", strip_info);
1957
1958 else if (has_prefix(msg, len, "006")) /* Header too big */
1959 RecvErr("Error Msg:", strip_info);
1960
1961 else if (has_prefix(msg, len, "007")) /* Body too big */
1962 {
1963 RecvErr("Error Msg:", strip_info);
1964 printk(KERN_ERR "%s: Error! Packet size too big for radio.\n",
1965 strip_info->dev.name);
1966 }
1967
1968 else if (has_prefix(msg, len, "008")) /* Bad character in name */
1969 {
1970 RecvErr("Error Msg:", strip_info);
1971 printk(KERN_ERR "%s: Radio name contains illegal character\n",
1972 strip_info->dev.name);
1973 }
1974
1975 else if (has_prefix(msg, len, "009")) /* No count or line terminator */
1976 RecvErr("Error Msg:", strip_info);
1977
1978 else if (has_prefix(msg, len, "010")) /* Invalid checksum */
1979 RecvErr("Error Msg:", strip_info);
1980
1981 else if (has_prefix(msg, len, "011")) /* Checksum didn't match */
1982 RecvErr("Error Msg:", strip_info);
1983
1984 else if (has_prefix(msg, len, "012")) /* Failed to transmit packet */
1985 RecvErr("Error Msg:", strip_info);
1986
1987 else
1988 RecvErr("Error Msg:", strip_info);
1989 }
1990
1991 static void process_AT_response(struct strip *strip_info, __u8 *ptr, __u8 *end)
1992 {
1993 u_long len;
1994 __u8 *p = ptr;
1995 while (p < end && p[-1] != 10) p++; /* Skip past first newline character */
1996 /* Now ptr points to the AT command, and p points to the text of the response. */
1997 len = p-ptr;
1998
1999 #if TICKLE_TIMERS
2000 {
2001 struct timeval tv;
2002 do_gettimeofday(&tv);
2003 printk(KERN_INFO "**** Got AT response %.7s at %02d.%06d\n",
2004 ptr, tv.tv_sec % 100, tv.tv_usec);
2005 }
2006 #endif
2007
2008 if (has_prefix(ptr, len, "ATS300?" )) get_radio_version(strip_info, p, end);
2009 else if (has_prefix(ptr, len, "ATS305?" )) get_radio_address(strip_info, p);
2010 else if (has_prefix(ptr, len, "ATS311?" )) get_radio_neighbours(&strip_info->poletops, p, end);
2011 else if (has_prefix(ptr, len, "ATS319=7")) verify_checksum(strip_info);
2012 else if (has_prefix(ptr, len, "ATS325?" )) get_radio_voltage(strip_info, p, end);
2013 else if (has_prefix(ptr, len, "AT~LA" )) get_radio_neighbours(&strip_info->portables, p, end);
2014 else RecvErr("Unknown AT Response:", strip_info);
2015 }
2016
2017 static void process_ACK(struct strip *strip_info, __u8 *ptr, __u8 *end)
2018 {
2019 /* Currently we don't do anything with ACKs from the radio */
2020 }
2021
2022 static void process_Info(struct strip *strip_info, __u8 *ptr, __u8 *end)
2023 {
2024 if (ptr+16 > end) RecvErr("Bad Info Msg:", strip_info);
2025 }
2026
2027 static struct net_device *get_strip_dev(struct strip *strip_info)
2028 {
2029 /* If our hardware address is *manually set* to zero, and we know our */
2030 /* real radio hardware address, try to find another strip device that has been */
2031 /* manually set to that address that we can 'transfer ownership' of this packet to */
2032 if (strip_info->manual_dev_addr &&
2033 !memcmp(strip_info->dev.dev_addr, zero_address.c, sizeof(zero_address)) &&
2034 memcmp(&strip_info->true_dev_addr, zero_address.c, sizeof(zero_address)))
2035 {
2036 struct net_device *dev;
2037 read_lock_bh(&dev_base_lock);
2038 dev = dev_base;
2039 while (dev)
2040 {
2041 if (dev->type == strip_info->dev.type &&
2042 !memcmp(dev->dev_addr, &strip_info->true_dev_addr, sizeof(MetricomAddress)))
2043 {
2044 printk(KERN_INFO "%s: Transferred packet ownership to %s.\n",
2045 strip_info->dev.name, dev->name);
2046 read_unlock_bh(&dev_base_lock);
2047 return(dev);
2048 }
2049 dev = dev->next;
2050 }
2051 read_unlock_bh(&dev_base_lock);
2052 }
2053 return(&strip_info->dev);
2054 }
2055
2056 /*
2057 * Send one completely decapsulated datagram to the next layer.
2058 */
2059
2060 static void deliver_packet(struct strip *strip_info, STRIP_Header *header, __u16 packetlen)
2061 {
2062 struct sk_buff *skb = dev_alloc_skb(sizeof(STRIP_Header) + packetlen);
2063 if (!skb)
2064 {
2065 printk(KERN_ERR "%s: memory squeeze, dropping packet.\n", strip_info->dev.name);
2066 strip_info->rx_dropped++;
2067 }
2068 else
2069 {
2070 memcpy(skb_put(skb, sizeof(STRIP_Header)), header, sizeof(STRIP_Header));
2071 memcpy(skb_put(skb, packetlen), strip_info->rx_buff, packetlen);
2072 skb->dev = get_strip_dev(strip_info);
2073 skb->protocol = header->protocol;
2074 skb->mac.raw = skb->data;
2075
2076 /* Having put a fake header on the front of the sk_buff for the */
2077 /* benefit of tools like tcpdump, skb_pull now 'consumes' that */
2078 /* fake header before we hand the packet up to the next layer. */
2079 skb_pull(skb, sizeof(STRIP_Header));
2080
2081 /* Finally, hand the packet up to the next layer (e.g. IP or ARP, etc.) */
2082 strip_info->rx_packets++;
2083 strip_info->rx_pps_count++;
2084 #ifdef EXT_COUNTERS
2085 strip_info->rx_bytes += packetlen;
2086 #endif
2087 netif_rx(skb);
2088 }
2089 }
2090
2091 static void process_IP_packet(struct strip *strip_info, STRIP_Header *header, __u8 *ptr, __u8 *end)
2092 {
2093 __u16 packetlen;
2094
2095 /* Decode start of the IP packet header */
2096 ptr = UnStuffData(ptr, end, strip_info->rx_buff, 4);
2097 if (!ptr)
2098 {
2099 RecvErr("IP Packet too short", strip_info);
2100 return;
2101 }
2102
2103 packetlen = ((__u16)strip_info->rx_buff[2] << 8) | strip_info->rx_buff[3];
2104
2105 if (packetlen > MAX_RECV_MTU)
2106 {
2107 printk(KERN_INFO "%s: Dropping oversized received IP packet: %d bytes\n",
2108 strip_info->dev.name, packetlen);
2109 strip_info->rx_dropped++;
2110 return;
2111 }
2112
2113 /*printk(KERN_INFO "%s: Got %d byte IP packet\n", strip_info->dev.name, packetlen);*/
2114
2115 /* Decode remainder of the IP packet */
2116 ptr = UnStuffData(ptr, end, strip_info->rx_buff+4, packetlen-4);
2117 if (!ptr)
2118 {
2119 RecvErr("IP Packet too short", strip_info);
2120 return;
2121 }
2122
2123 if (ptr < end)
2124 {
2125 RecvErr("IP Packet too long", strip_info);
2126 return;
2127 }
2128
2129 header->protocol = htons(ETH_P_IP);
2130
2131 deliver_packet(strip_info, header, packetlen);
2132 }
2133
2134 static void process_ARP_packet(struct strip *strip_info, STRIP_Header *header, __u8 *ptr, __u8 *end)
2135 {
2136 __u16 packetlen;
2137 struct arphdr *arphdr = (struct arphdr *)strip_info->rx_buff;
2138
2139 /* Decode start of the ARP packet */
2140 ptr = UnStuffData(ptr, end, strip_info->rx_buff, 8);
2141 if (!ptr)
2142 {
2143 RecvErr("ARP Packet too short", strip_info);
2144 return;
2145 }
2146
2147 packetlen = 8 + (arphdr->ar_hln + arphdr->ar_pln) * 2;
2148
2149 if (packetlen > MAX_RECV_MTU)
2150 {
2151 printk(KERN_INFO "%s: Dropping oversized received ARP packet: %d bytes\n",
2152 strip_info->dev.name, packetlen);
2153 strip_info->rx_dropped++;
2154 return;
2155 }
2156
2157 /*printk(KERN_INFO "%s: Got %d byte ARP %s\n",
2158 strip_info->dev.name, packetlen,
2159 ntohs(arphdr->ar_op) == ARPOP_REQUEST ? "request" : "reply");*/
2160
2161 /* Decode remainder of the ARP packet */
2162 ptr = UnStuffData(ptr, end, strip_info->rx_buff+8, packetlen-8);
2163 if (!ptr)
2164 {
2165 RecvErr("ARP Packet too short", strip_info);
2166 return;
2167 }
2168
2169 if (ptr < end)
2170 {
2171 RecvErr("ARP Packet too long", strip_info);
2172 return;
2173 }
2174
2175 header->protocol = htons(ETH_P_ARP);
2176
2177 deliver_packet(strip_info, header, packetlen);
2178 }
2179
2180 /*
2181 * process_text_message processes a <CR>-terminated block of data received
2182 * from the radio that doesn't begin with a '*' character. All normal
2183 * Starmode communication messages with the radio begin with a '*',
2184 * so any text that does not indicates a serial port error, a radio that
2185 * is in Hayes command mode instead of Starmode, or a radio with really
2186 * old firmware that doesn't frame its Starmode responses properly.
2187 */
2188 static void process_text_message(struct strip *strip_info)
2189 {
2190 __u8 *msg = strip_info->sx_buff;
2191 int len = strip_info->sx_count;
2192
2193 /* Check for anything that looks like it might be our radio name */
2194 /* (This is here for backwards compatibility with old firmware) */
2195 if (len == 9 && get_radio_address(strip_info, msg) == 0) return;
2196
2197 if (text_equal(msg, len, "OK" )) return; /* Ignore 'OK' responses from prior commands */
2198 if (text_equal(msg, len, "ERROR" )) return; /* Ignore 'ERROR' messages */
2199 if (has_prefix(msg, len, "ate0q1" )) return; /* Ignore character echo back from the radio */
2200
2201 /* Catch other error messages */
2202 /* (This is here for backwards compatibility with old firmware) */
2203 if (has_prefix(msg, len, "ERR_")) { RecvErr_Message(strip_info, NULL, &msg[4], len-4); return; }
2204
2205 RecvErr("No initial *", strip_info);
2206 }
2207
2208 /*
2209 * process_message processes a <CR>-terminated block of data received
2210 * from the radio. If the radio is not in Starmode or has old firmware,
2211 * it may be a line of text in response to an AT command. Ideally, with
2212 * a current radio that's properly in Starmode, all data received should
2213 * be properly framed and checksummed radio message blocks, containing
2214 * either a starmode packet, or a other communication from the radio
2215 * firmware, like "INF_" Info messages and &COMMAND responses.
2216 */
2217 static void process_message(struct strip *strip_info)
2218 {
2219 STRIP_Header header = { zero_address, zero_address, 0 };
2220 __u8 *ptr = strip_info->sx_buff;
2221 __u8 *end = strip_info->sx_buff + strip_info->sx_count;
2222 __u8 sendername[32], *sptr = sendername;
2223 MetricomKey key;
2224
2225 /*HexDump("Receiving", strip_info, ptr, end);*/
2226
2227 /* Check for start of address marker, and then skip over it */
2228 if (*ptr == '*') ptr++;
2229 else { process_text_message(strip_info); return; }
2230
2231 /* Copy out the return address */
2232 while (ptr < end && *ptr != '*' && sptr < ARRAY_END(sendername)-1) *sptr++ = *ptr++;
2233 *sptr = 0; /* Null terminate the sender name */
2234
2235 /* Check for end of address marker, and skip over it */
2236 if (ptr >= end || *ptr != '*')
2237 {
2238 RecvErr("No second *", strip_info);
2239 return;
2240 }
2241 ptr++; /* Skip the second '*' */
2242
2243 /* If the sender name is "&COMMAND", ignore this 'packet' */
2244 /* (This is here for backwards compatibility with old firmware) */
2245 if (!strcmp(sendername, "&COMMAND"))
2246 {
2247 strip_info->firmware_level = NoStructure;
2248 strip_info->next_command = CompatibilityCommand;
2249 return;
2250 }
2251
2252 if (ptr+4 > end)
2253 {
2254 RecvErr("No proto key", strip_info);
2255 return;
2256 }
2257
2258 /* Get the protocol key out of the buffer */
2259 key.c[0] = *ptr++;
2260 key.c[1] = *ptr++;
2261 key.c[2] = *ptr++;
2262 key.c[3] = *ptr++;
2263
2264 /* If we're using checksums, verify the checksum at the end of the packet */
2265 if (strip_info->firmware_level >= ChecksummedMessages)
2266 {
2267 end -= 4; /* Chop the last four bytes off the packet (they're the checksum) */
2268 if (ptr > end)
2269 {
2270 RecvErr("Missing Checksum", strip_info);
2271 return;
2272 }
2273 if (!verify_checksum(strip_info))
2274 {
2275 RecvErr("Bad Checksum", strip_info);
2276 return;
2277 }
2278 }
2279
2280 /*printk(KERN_INFO "%s: Got packet from \"%s\".\n", strip_info->dev.name, sendername);*/
2281
2282 /*
2283 * Fill in (pseudo) source and destination addresses in the packet.
2284 * We assume that the destination address was our address (the radio does not
2285 * tell us this). If the radio supplies a source address, then we use it.
2286 */
2287 header.dst_addr = strip_info->true_dev_addr;
2288 string_to_radio_address(&header.src_addr, sendername);
2289
2290 #ifdef EXT_COUNTERS
2291 if (key.l == SIP0Key.l) {
2292 strip_info->rx_rbytes += (end - ptr);
2293 process_IP_packet(strip_info, &header, ptr, end);
2294 } else if (key.l == ARP0Key.l) {
2295 strip_info->rx_rbytes += (end - ptr);
2296 process_ARP_packet(strip_info, &header, ptr, end);
2297 } else if (key.l == ATR_Key.l) {
2298 strip_info->rx_ebytes += (end - ptr);
2299 process_AT_response(strip_info, ptr, end);
2300 } else if (key.l == ACK_Key.l) {
2301 strip_info->rx_ebytes += (end - ptr);
2302 process_ACK(strip_info, ptr, end);
2303 } else if (key.l == INF_Key.l) {
2304 strip_info->rx_ebytes += (end - ptr);
2305 process_Info(strip_info, ptr, end);
2306 } else if (key.l == ERR_Key.l) {
2307 strip_info->rx_ebytes += (end - ptr);
2308 RecvErr_Message(strip_info, sendername, ptr, end-ptr);
2309 } else RecvErr("Unrecognized protocol key", strip_info);
2310 #else
2311 if (key.l == SIP0Key.l) process_IP_packet (strip_info, &header, ptr, end);
2312 else if (key.l == ARP0Key.l) process_ARP_packet (strip_info, &header, ptr, end);
2313 else if (key.l == ATR_Key.l) process_AT_response(strip_info, ptr, end);
2314 else if (key.l == ACK_Key.l) process_ACK (strip_info, ptr, end);
2315 else if (key.l == INF_Key.l) process_Info (strip_info, ptr, end);
2316 else if (key.l == ERR_Key.l) RecvErr_Message (strip_info, sendername, ptr, end-ptr);
2317 else RecvErr("Unrecognized protocol key", strip_info);
2318 #endif
2319 }
2320
2321 #define TTYERROR(X) ((X) == TTY_BREAK ? "Break" : \
2322 (X) == TTY_FRAME ? "Framing Error" : \
2323 (X) == TTY_PARITY ? "Parity Error" : \
2324 (X) == TTY_OVERRUN ? "Hardware Overrun" : "Unknown Error")
2325
2326 /*
2327 * Handle the 'receiver data ready' interrupt.
2328 * This function is called by the 'tty_io' module in the kernel when
2329 * a block of STRIP data has been received, which can now be decapsulated
2330 * and sent on to some IP layer for further processing.
2331 */
2332
2333 static void
2334 strip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
2335 {
2336 struct strip *strip_info = (struct strip *) tty->disc_data;
2337 const unsigned char *end = cp + count;
2338
2339 if (!strip_info || strip_info->magic != STRIP_MAGIC
2340 || !netif_running(&strip_info->dev))
2341 return;
2342
2343 /* Argh! mtu change time! - costs us the packet part received at the change */
2344 if (strip_info->mtu != strip_info->dev.mtu)
2345 strip_changedmtu(strip_info);
2346
2347 #if 0
2348 {
2349 struct timeval tv;
2350 do_gettimeofday(&tv);
2351 printk(KERN_INFO "**** strip_receive_buf: %3d bytes at %02d.%06d\n",
2352 count, tv.tv_sec % 100, tv.tv_usec);
2353 }
2354 #endif
2355
2356 #ifdef EXT_COUNTERS
2357 strip_info->rx_sbytes += count;
2358 #endif
2359
2360 /* Read the characters out of the buffer */
2361 while (cp < end)
2362 {
2363 if (fp && *fp) printk(KERN_INFO "%s: %s on serial port\n", strip_info->dev.name, TTYERROR(*fp));
2364 if (fp && *fp++ && !strip_info->discard) /* If there's a serial error, record it */
2365 {
2366 /* If we have some characters in the buffer, discard them */
2367 strip_info->discard = strip_info->sx_count;
2368 strip_info->rx_errors++;
2369 }
2370
2371 /* Leading control characters (CR, NL, Tab, etc.) are ignored */
2372 if (strip_info->sx_count > 0 || *cp >= ' ')
2373 {
2374 if (*cp == 0x0D) /* If end of packet, decide what to do with it */
2375 {
2376 if (strip_info->sx_count > 3000)
2377 printk(KERN_INFO "%s: Cut a %d byte packet (%d bytes remaining)%s\n",
2378 strip_info->dev.name, strip_info->sx_count, end-cp-1,
2379 strip_info->discard ? " (discarded)" : "");
2380 if (strip_info->sx_count > strip_info->sx_size)
2381 {
2382 strip_info->rx_over_errors++;
2383 printk(KERN_INFO "%s: sx_buff overflow (%d bytes total)\n",
2384 strip_info->dev.name, strip_info->sx_count);
2385 }
2386 else if (strip_info->discard)
2387 printk(KERN_INFO "%s: Discarding bad packet (%d/%d)\n",
2388 strip_info->dev.name, strip_info->discard, strip_info->sx_count);
2389 else process_message(strip_info);
2390 strip_info->discard = 0;
2391 strip_info->sx_count = 0;
2392 }
2393 else
2394 {
2395 /* Make sure we have space in the buffer */
2396 if (strip_info->sx_count < strip_info->sx_size)
2397 strip_info->sx_buff[strip_info->sx_count] = *cp;
2398 strip_info->sx_count++;
2399 }
2400 }
2401 cp++;
2402 }
2403 }
2404
2405
2406 /************************************************************************/
2407 /* General control routines */
2408
2409 static int set_mac_address(struct strip *strip_info, MetricomAddress *addr)
2410 {
2411 /*
2412 * We're using a manually specified address if the address is set
2413 * to anything other than all ones. Setting the address to all ones
2414 * disables manual mode and goes back to automatic address determination
2415 * (tracking the true address that the radio has).
2416 */
2417 strip_info->manual_dev_addr = memcmp(addr->c, broadcast_address.c, sizeof(broadcast_address));
2418 if (strip_info->manual_dev_addr)
2419 *(MetricomAddress*)strip_info->dev.dev_addr = *addr;
2420 else *(MetricomAddress*)strip_info->dev.dev_addr = strip_info->true_dev_addr;
2421 return 0;
2422 }
2423
2424 static int dev_set_mac_address(struct net_device *dev, void *addr)
2425 {
2426 struct strip *strip_info = (struct strip *)(dev->priv);
2427 struct sockaddr *sa = addr;
2428 printk(KERN_INFO "%s: strip_set_dev_mac_address called\n", dev->name);
2429 set_mac_address(strip_info, (MetricomAddress *)sa->sa_data);
2430 return 0;
2431 }
2432
2433 static struct net_device_stats *strip_get_stats(struct net_device *dev)
2434 {
2435 static struct net_device_stats stats;
2436 struct strip *strip_info = (struct strip *)(dev->priv);
2437
2438 memset(&stats, 0, sizeof(struct net_device_stats));
2439
2440 stats.rx_packets = strip_info->rx_packets;
2441 stats.tx_packets = strip_info->tx_packets;
2442 stats.rx_dropped = strip_info->rx_dropped;
2443 stats.tx_dropped = strip_info->tx_dropped;
2444 stats.tx_errors = strip_info->tx_errors;
2445 stats.rx_errors = strip_info->rx_errors;
2446 stats.rx_over_errors = strip_info->rx_over_errors;
2447 return(&stats);
2448 }
2449
2450
2451 /************************************************************************/
2452 /* Opening and closing */
2453
2454 /*
2455 * Here's the order things happen:
2456 * When the user runs "slattach -p strip ..."
2457 * 1. The TTY module calls strip_open
2458 * 2. strip_open calls strip_alloc
2459 * 3. strip_alloc calls register_netdev
2460 * 4. register_netdev calls strip_dev_init
2461 * 5. then strip_open finishes setting up the strip_info
2462 *
2463 * When the user runs "ifconfig st<x> up address netmask ..."
2464 * 6. strip_open_low gets called
2465 *
2466 * When the user runs "ifconfig st<x> down"
2467 * 7. strip_close_low gets called
2468 *
2469 * When the user kills the slattach process
2470 * 8. strip_close gets called
2471 * 9. strip_close calls dev_close
2472 * 10. if the device is still up, then dev_close calls strip_close_low
2473 * 11. strip_close calls strip_free
2474 */
2475
2476 /* Open the low-level part of the STRIP channel. Easy! */
2477
2478 static int strip_open_low(struct net_device *dev)
2479 {
2480 struct strip *strip_info = (struct strip *)(dev->priv);
2481 #if 0
2482 struct in_device *in_dev = dev->ip_ptr;
2483 #endif
2484
2485 if (strip_info->tty == NULL)
2486 return(-ENODEV);
2487
2488 if (!allocate_buffers(strip_info))
2489 return(-ENOMEM);
2490
2491 strip_info->sx_count = 0;
2492 strip_info->tx_left = 0;
2493
2494 strip_info->discard = 0;
2495 strip_info->working = FALSE;
2496 strip_info->firmware_level = NoStructure;
2497 strip_info->next_command = CompatibilityCommand;
2498 strip_info->user_baud = get_baud(strip_info->tty);
2499
2500 #if 0
2501 /*
2502 * Needed because address '' is special
2503 *
2504 * --ANK Needed it or not needed, it does not matter at all.
2505 * Make it at user level, guys.
2506 */
2507
2508 if (in_dev->ifa_list->ifa_address == 0)
2509 in_dev->ifa_list->ifa_address = ntohl(0xC0A80001);
2510 #endif
2511 printk(KERN_INFO "%s: Initializing Radio.\n", strip_info->dev.name);
2512 ResetRadio(strip_info);
2513 strip_info->idle_timer.expires = jiffies + 1*HZ;
2514 add_timer(&strip_info->idle_timer);
2515 netif_wake_queue(dev);
2516 return(0);
2517 }
2518
2519
2520 /*
2521 * Close the low-level part of the STRIP channel. Easy!
2522 */
2523
2524 static int strip_close_low(struct net_device *dev)
2525 {
2526 struct strip *strip_info = (struct strip *)(dev->priv);
2527
2528 if (strip_info->tty == NULL)
2529 return -EBUSY;
2530 strip_info->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
2531
2532 netif_stop_queue(dev);
2533
2534 /*
2535 * Free all STRIP frame buffers.
2536 */
2537 if (strip_info->rx_buff)
2538 {
2539 kfree(strip_info->rx_buff);
2540 strip_info->rx_buff = NULL;
2541 }
2542 if (strip_info->sx_buff)
2543 {
2544 kfree(strip_info->sx_buff);
2545 strip_info->sx_buff = NULL;
2546 }
2547 if (strip_info->tx_buff)
2548 {
2549 kfree(strip_info->tx_buff);
2550 strip_info->tx_buff = NULL;
2551 }
2552 del_timer(&strip_info->idle_timer);
2553 return 0;
2554 }
2555
2556 /*
2557 * This routine is called by DDI when the
2558 * (dynamically assigned) device is registered
2559 */
2560
2561 static int strip_dev_init(struct net_device *dev)
2562 {
2563 /*
2564 * Finish setting up the DEVICE info.
2565 */
2566
2567 dev->trans_start = 0;
2568 dev->last_rx = 0;
2569 dev->tx_queue_len = 30; /* Drop after 30 frames queued */
2570
2571 dev->flags = 0;
2572 dev->mtu = DEFAULT_STRIP_MTU;
2573 dev->type = ARPHRD_METRICOM; /* dtang */
2574 dev->hard_header_len = sizeof(STRIP_Header);
2575 /*
2576 * dev->priv Already holds a pointer to our struct strip
2577 */
2578
2579 *(MetricomAddress*)&dev->broadcast = broadcast_address;
2580 dev->dev_addr[0] = 0;
2581 dev->addr_len = sizeof(MetricomAddress);
2582
2583 /*
2584 * Pointers to interface service routines.
2585 */
2586
2587 dev->open = strip_open_low;
2588 dev->stop = strip_close_low;
2589 dev->hard_start_xmit = strip_xmit;
2590 dev->hard_header = strip_header;
2591 dev->rebuild_header = strip_rebuild_header;
2592 /* dev->type_trans unused */
2593 /* dev->set_multicast_list unused */
2594 dev->set_mac_address = dev_set_mac_address;
2595 /* dev->do_ioctl unused */
2596 /* dev->set_config unused */
2597 dev->get_stats = strip_get_stats;
2598 return 0;
2599 }
2600
2601 /*
2602 * Free a STRIP channel.
2603 */
2604
2605 static void strip_free(struct strip *strip_info)
2606 {
2607 *(strip_info->referrer) = strip_info->next;
2608 if (strip_info->next)
2609 strip_info->next->referrer = strip_info->referrer;
2610 strip_info->magic = 0;
2611 kfree(strip_info);
2612 }
2613
2614 /*
2615 * Allocate a new free STRIP channel
2616 */
2617
2618 static struct strip *strip_alloc(void)
2619 {
2620 int channel_id = 0;
2621 struct strip **s = &struct_strip_list;
2622 struct strip *strip_info = (struct strip *)
2623 kmalloc(sizeof(struct strip), GFP_KERNEL);
2624
2625 if (!strip_info)
2626 return(NULL); /* If no more memory, return */
2627
2628 /*
2629 * Clear the allocated memory
2630 */
2631
2632 memset(strip_info, 0, sizeof(struct strip));
2633
2634 /*
2635 * Search the list to find where to put our new entry
2636 * (and in the process decide what channel number it is
2637 * going to be)
2638 */
2639
2640 while (*s && (*s)->dev.base_addr == channel_id)
2641 {
2642 channel_id++;
2643 s = &(*s)->next;
2644 }
2645
2646 /*
2647 * Fill in the link pointers
2648 */
2649
2650 strip_info->next = *s;
2651 if (*s)
2652 (*s)->referrer = &strip_info->next;
2653 strip_info->referrer = s;
2654 *s = strip_info;
2655
2656 strip_info->magic = STRIP_MAGIC;
2657 strip_info->tty = NULL;
2658
2659 strip_info->gratuitous_arp = jiffies + LongTime;
2660 strip_info->arp_interval = 0;
2661 init_timer(&strip_info->idle_timer);
2662 strip_info->idle_timer.data = (long)&strip_info->dev;
2663 strip_info->idle_timer.function = strip_IdleTask;
2664
2665 /* Note: strip_info->if_name is currently 8 characters long */
2666 sprintf(strip_info->dev.name, "st%d", channel_id);
2667 strip_info->dev.base_addr = channel_id;
2668 strip_info->dev.priv = (void*)strip_info;
2669 strip_info->dev.next = NULL;
2670 strip_info->dev.init = strip_dev_init;
2671
2672 return(strip_info);
2673 }
2674
2675 /*
2676 * Open the high-level part of the STRIP channel.
2677 * This function is called by the TTY module when the
2678 * STRIP line discipline is called for. Because we are
2679 * sure the tty line exists, we only have to link it to
2680 * a free STRIP channel...
2681 */
2682
2683 static int strip_open(struct tty_struct *tty)
2684 {
2685 struct strip *strip_info = (struct strip *) tty->disc_data;
2686
2687 /*
2688 * First make sure we're not already connected.
2689 */
2690
2691 if (strip_info && strip_info->magic == STRIP_MAGIC)
2692 return -EEXIST;
2693
2694 /*
2695 * OK. Find a free STRIP channel to use.
2696 */
2697 if ((strip_info = strip_alloc()) == NULL)
2698 return -ENFILE;
2699
2700 /*
2701 * Register our newly created device so it can be ifconfig'd
2702 * strip_dev_init() will be called as a side-effect
2703 */
2704
2705 if (register_netdev(&strip_info->dev) != 0)
2706 {
2707 printk(KERN_ERR "strip: register_netdev() failed.\n");
2708 strip_free(strip_info);
2709 return -ENFILE;
2710 }
2711
2712 strip_info->tty = tty;
2713 tty->disc_data = strip_info;
2714 if (tty->driver.flush_buffer)
2715 tty->driver.flush_buffer(tty);
2716 if (tty->ldisc.flush_buffer)
2717 tty->ldisc.flush_buffer(tty);
2718
2719 /*
2720 * Restore default settings
2721 */
2722
2723 strip_info->dev.type = ARPHRD_METRICOM; /* dtang */
2724
2725 /*
2726 * Set tty options
2727 */
2728
2729 tty->termios->c_iflag |= IGNBRK |IGNPAR;/* Ignore breaks and parity errors. */
2730 tty->termios->c_cflag |= CLOCAL; /* Ignore modem control signals. */
2731 tty->termios->c_cflag &= ~HUPCL; /* Don't close on hup */
2732
2733 #ifdef MODULE
2734 MOD_INC_USE_COUNT;
2735 #endif
2736
2737 printk(KERN_INFO "STRIP: device \"%s\" activated\n", strip_info->dev.name);
2738
2739 /*
2740 * Done. We have linked the TTY line to a channel.
2741 */
2742 return(strip_info->dev.base_addr);
2743 }
2744
2745 /*
2746 * Close down a STRIP channel.
2747 * This means flushing out any pending queues, and then restoring the
2748 * TTY line discipline to what it was before it got hooked to STRIP
2749 * (which usually is TTY again).
2750 */
2751
2752 static void strip_close(struct tty_struct *tty)
2753 {
2754 struct strip *strip_info = (struct strip *) tty->disc_data;
2755
2756 /*
2757 * First make sure we're connected.
2758 */
2759
2760 if (!strip_info || strip_info->magic != STRIP_MAGIC)
2761 return;
2762
2763 dev_close(&strip_info->dev);
2764 unregister_netdev(&strip_info->dev);
2765
2766 tty->disc_data = 0;
2767 strip_info->tty = NULL;
2768 printk(KERN_INFO "STRIP: device \"%s\" closed down\n", strip_info->dev.name);
2769 strip_free(strip_info);
2770 tty->disc_data = NULL;
2771 #ifdef MODULE
2772 MOD_DEC_USE_COUNT;
2773 #endif
2774 }
2775
2776
2777 /************************************************************************/
2778 /* Perform I/O control calls on an active STRIP channel. */
2779
2780 static int strip_ioctl(struct tty_struct *tty, struct file *file,
2781 unsigned int cmd, unsigned long arg)
2782 {
2783 struct strip *strip_info = (struct strip *) tty->disc_data;
2784
2785 /*
2786 * First make sure we're connected.
2787 */
2788
2789 if (!strip_info || strip_info->magic != STRIP_MAGIC)
2790 return -EINVAL;
2791
2792 switch(cmd)
2793 {
2794 case SIOCGIFNAME:
2795 return copy_to_user((void*)arg, strip_info->dev.name,
2796 strlen(strip_info->dev.name) + 1) ?
2797 -EFAULT : 0;
2798 break;
2799 case SIOCSIFHWADDR:
2800 {
2801 MetricomAddress addr;
2802 printk(KERN_INFO "%s: SIOCSIFHWADDR\n", strip_info->dev.name);
2803 return copy_from_user(&addr, (void*)arg, sizeof(MetricomAddress)) ?
2804 -EFAULT : set_mac_address(strip_info, &addr);
2805 break;
2806 }
2807 /*
2808 * Allow stty to read, but not set, the serial port
2809 */
2810
2811 case TCGETS:
2812 case TCGETA:
2813 return n_tty_ioctl(tty, (struct file *) file, cmd,
2814 (unsigned long) arg);
2815 break;
2816 default:
2817 return -ENOIOCTLCMD;
2818 break;
2819 }
2820 }
2821
2822
2823 /************************************************************************/
2824 /* Initialization */
2825
2826 /*
2827 * Initialize the STRIP driver.
2828 * This routine is called at boot time, to bootstrap the multi-channel
2829 * STRIP driver
2830 */
2831
2832 int strip_init_ctrl_dev(struct net_device *dummy)
2833 {
2834 static struct tty_ldisc strip_ldisc;
2835 int status;
2836
2837 printk(KERN_INFO "STRIP: Version %s (unlimited channels)\n", StripVersion);
2838
2839 /*
2840 * Fill in our line protocol discipline, and register it
2841 */
2842
2843 memset(&strip_ldisc, 0, sizeof(strip_ldisc));
2844 strip_ldisc.magic = TTY_LDISC_MAGIC;
2845 strip_ldisc.flags = 0;
2846 strip_ldisc.open = strip_open;
2847 strip_ldisc.close = strip_close;
2848 strip_ldisc.read = NULL;
2849 strip_ldisc.write = NULL;
2850 strip_ldisc.ioctl = strip_ioctl;
2851 strip_ldisc.poll = NULL;
2852 strip_ldisc.receive_buf = strip_receive_buf;
2853 strip_ldisc.receive_room = strip_receive_room;
2854 strip_ldisc.write_wakeup = strip_write_some_more;
2855 status = tty_register_ldisc(N_STRIP, &strip_ldisc);
2856 if (status != 0)
2857 {
2858 printk(KERN_ERR "STRIP: can't register line discipline (err = %d)\n", status);
2859 }
2860
2861 /*
2862 * Register the status file with /proc
2863 */
2864 proc_net_create ("strip", S_IFREG | S_IRUGO, get_status_info);
2865
2866 #ifdef MODULE
2867 return status;
2868 #else
2869
2870 /* Return "not found", so that dev_init() will unlink
2871 * the placeholder device entry for us.
2872 */
2873 return -ENODEV;
2874 #endif
2875 }
2876
2877
2878 /************************************************************************/
2879 /* From here down is only used when compiled as an external module */
2880
2881 #ifdef MODULE
2882
2883 int init_module(void)
2884 {
2885 return strip_init_ctrl_dev(0);
2886 }
2887
2888 void cleanup_module(void)
2889 {
2890 int i;
2891 while (struct_strip_list)
2892 strip_free(struct_strip_list);
2893
2894 /* Unregister with the /proc/net file here. */
2895 proc_net_remove ("strip");
2896
2897 if ((i = tty_register_ldisc(N_STRIP, NULL)))
2898 printk(KERN_ERR "STRIP: can't unregister line discipline (err = %d)\n", i);
2899
2900 printk(KERN_INFO "STRIP: Module Unloaded\n");
2901 }
2902 #endif /* MODULE */
2903
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.