/*
* Copyright 1996 The Board of Trustees of The Leland Stanford
* Junior University. All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this
* software and its documentation for any purpose and without
* fee is hereby granted, provided that the above copyright
* notice appear in all copies. Stanford University
* makes no representations about the suitability of this
* software for any purpose. It is provided "as is" without
* express or implied warranty.
*
* strip.c This module implements Starmode Radio IP (STRIP)
* for kernel-based devices like TTY. It interfaces between a
* raw TTY, and the kernel's INET protocol layers (via DDI).
*
* Version: @(#)strip.c 0.9.8 June 1996
*
* Author: Stuart Cheshire <cheshire@cs.stanford.edu>
*
* Fixes: v0.9 12th Feb 1996.
* New byte stuffing (2+6 run-length encoding)
* New watchdog timer task
* New Protocol key (SIP0)
*
* v0.9.1 3rd March 1996
* Changed to dynamic device allocation -- no more compile
* time (or boot time) limit on the number of STRIP devices.
*
* v0.9.2 13th March 1996
* Uses arp cache lookups (but doesn't send arp packets yet)
*
* v0.9.3 17th April 1996
* Fixed bug where STR_ERROR flag was getting set unneccessarily
*
* v0.9.4 27th April 1996
* First attempt at using "&COMMAND" Starmode AT commands
*
* v0.9.5 29th May 1996
* First attempt at sending (unicast) ARP packets
*
* v0.9.6 5th June 1996
* Elliot put "message level" tags in every "printk" statement
*
* v0.9.7 13th June 1996
* Added support for the /proc fs (laik)
*
* v0.9.8 July 1996
* Added packet logging (Mema)
*/
/*
* Undefine this symbol if you don't have PROC_NET_STRIP_STATUS
* defined in include/linux/proc_fs.h
*/
#define DO_PROC_NET_STRIP_STATUS 1
/*
* Define this symbol if you want to enable STRIP packet tracing.
*/
#define DO_PROC_NET_STRIP_TRACE 0
/************************************************************************/
/* Header files */
#include <linux/config.h>
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#endif
#include <stdlib.h>
#include <asm/system.h>
#include <asm/segment.h>
#include <asm/bitops.h>
/*
* isdigit() and isspace() use the ctype[] array, which is not available
* to kernel modules. If compiling as a module, use a local definition
* of isdigit() and isspace() until _ctype is added to ksyms.
*/
#ifdef MODULE
# define isdigit(c) ('0' <= (c) && (c) <= '9')
# define isspace(c) ((c) == ' ' || (c) == '\t')
#else
# include <linux/ctype.h>
#endif
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/in.h>
#include <linux/tty.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/if_arp.h>
#include <linux/if_strip.h>
#include <linux/proc_fs.h>
#include <net/arp.h>
#ifdef CONFIG_INET
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/time.h>
#endif
/************************************************************************/
/* Useful structures and definitions */
/*
* A MetricomKey identifies the protocol being carried inside a Metricom
* Starmode packet.
*/
typedef union
{
__u8 c[4];
__u32 l;
} MetricomKey;
/*
* An IP address can be viewed as four bytes in memory (which is what it is) or as
* a single 32-bit long (which is convenient for assignment, equality testing etc.)
*/
typedef union
{
__u8 b[4];
__u32 l;
} IPaddr;
/*
* A MetricomAddressString is used to hold a printable representation of
* a Metricom address.
*/
typedef struct
{
__u8 c[24];
} MetricomAddressString;
/*
* Note: A Metricom packet looks like this: *<address>*<key><payload><CR>
* eg. *0000-1234*SIP0<payload><CR>
* A STRIP_Header is never really sent over the radio, but making a dummy header
* for internal use within the kernel that looks like an Ethernet header makes
* certain other software happier. For example, tcpdump already understands
* Ethernet headers.
*/
typedef struct
{
MetricomAddress dst_addr; /* Destination address, e.g. "0000-1234" */
MetricomAddress src_addr; /* Source address, e.g. "0000-5678" */
unsigned short protocol; /* The protocol type, using Ethernet codes */
} STRIP_Header;
typedef struct GeographicLocation
{
char s[18];
} GeographicLocation;
typedef enum {
NodeValid = 0x1,
NodeHasWAN = 0x2,
NodeIsRouter = 0x4
} NodeType;
typedef struct MetricomNode
{
NodeType type; /* Some flags about the type of node */
GeographicLocation gl; /* The location of the node. */
MetricomAddress addr; /* The metricom address of this node */
int poll_latency; /* The latency to poll that node ? */
int rssi; /* The Receiver Signal Strength Indicator */
struct MetricomNode *next; /* The next node */
} MetricomNode;
enum { FALSE = 0, TRUE = 1 };
/*
* Holds the packet signature for an IP packet.
*/
typedef struct
{
IPaddr src;
/* Data is stored in the following field in network byte order. */
__u16 id;
} IPSignature;
/*
* Holds the packet signature for an ARP packet.
*/
typedef struct
{
IPaddr src;
/* Data is stored in the following field in network byte order. */
__u16 op;
} ARPSignature;
/*
* Holds the signature of a packet.
*/
typedef union
{
IPSignature ip_sig;
ARPSignature arp_sig;
__u8 print_sig[6];
} PacketSignature;
typedef enum {
EntrySend = 0,
EntryReceive = 1
} LogEntry;
/* Structure for Packet Logging */
typedef struct stripLog
{
LogEntry entry_type;
u_long seqNum;
int packet_type;
PacketSignature sig;
MetricomAddress src;
MetricomAddress dest;
struct timeval timeStamp;
u_long rawSize;
u_long stripSize;
u_long slipSize;
u_long valid;
} StripLog;
#define ENTRY_TYPE_TO_STRING(X) ((X) ? "r" : "s")
#define BOOLEAN_TO_STRING(X) ((X) ? "true" : "false")
/*
* Holds the radio's firmware version.
*/
typedef struct
{
char c[50];
} MetricomFirmwareVersion;
/*
* Holds the radio's serial number.
*/
typedef struct
{
char c[18];
} MetricomSerialNumber;
/*
* Holds the radio's battery voltage.
*/
typedef struct
{
char c[11];
} MetricomBatteryVoltage;
struct strip
{
int magic;
/*
* These are pointers to the malloc()ed frame buffers.
*/
unsigned char *rx_buff; /* buffer for received IP packet*/
unsigned char *sx_buff; /* buffer for received serial data*/
int sx_count; /* received serial data counter */
int sx_size; /* Serial buffer size */
unsigned char *tx_buff; /* transmitter buffer */
unsigned char *tx_head; /* pointer to next byte to XMIT */
int tx_left; /* bytes left in XMIT queue */
int tx_size; /* Serial buffer size */
/*
* STRIP interface statistics.
*/
unsigned long rx_packets; /* inbound frames counter */
unsigned long tx_packets; /* outbound frames counter */
unsigned long rx_errors; /* Parity, etc. errors */
unsigned long tx_errors; /* Planned stuff */
unsigned long rx_dropped; /* No memory for skb */
unsigned long tx_dropped; /* When MTU change */
unsigned long rx_over_errors; /* Frame bigger then STRIP buf. */
/*
* Internal variables.
*/
struct strip *next; /* The next struct in the list */
struct strip **referrer; /* The pointer that points to us*/
int discard; /* Set if serial error */
int working; /* Is radio working correctly? */
int structured_messages; /* Parsable AT response msgs? */
int mtu; /* Our mtu (to spot changes!) */
long watchdog_doprobe; /* Next time to test the radio */
long watchdog_doreset; /* Time to do next reset */
long gratuitous_arp; /* Time to send next ARP refresh*/
long arp_interval; /* Next ARP interval */
struct timer_list idle_timer; /* For periodic wakeup calls */
MetricomNode *neighbor_list; /* The list of neighbor nodes */
int neighbor_list_locked; /* Indicates the list is locked */
MetricomFirmwareVersion firmware_version; /* The radio's firmware version */
MetricomSerialNumber serial_number; /* The radio's serial number */
MetricomBatteryVoltage battery_voltage; /* The radio's battery voltage */
/*
* Other useful structures.
*/
struct tty_struct *tty; /* ptr to TTY structure */
char if_name[8]; /* Dynamically generated name */
struct device dev; /* Our device structure */
/*
* Packet Logging Structures.
*/
u_long num_sent;
u_long num_received;
int next_entry; /* The index of the oldest packet; */
/* Also the next to be logged. */
StripLog packetLog[610];
};
/************************************************************************/
/* Constants */
#ifdef MODULE
static const char StripVersion[] = "0.9.8-STUART.CHESHIRE-MODULAR";
#else
static const char StripVersion[] = "0.9.8-STUART.CHESHIRE";
#endif
static const char TickleString1[] = "***&COMMAND*ATS305?\r";
static const char TickleString2[] = "***&COMMAND*ATS305?\r\r"
"*&COMMAND*ATS300?\r\r*&COMMAND*ATS325?\r\r*&COMMAND*AT~I2 nn\r\r";
static const char hextable[16] = "0123456789ABCDEF";
static const MetricomAddress zero_address;
static const MetricomAddress broadcast_address = { { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF } };
static const MetricomKey SIP0Key = { { "SIP0" } };
static const MetricomKey ARP0Key = { { "ARP0" } };
static const MetricomKey ERR_Key = { { "ERR_" } };
static const MetricomKey ATR_Key = { { "ATR " } };
static const long MaxARPInterval = 60 * HZ; /* One minute */
/*
* Maximum Starmode packet length (including starmode address) is 1183 bytes.
* Allowing 32 bytes for header, and 65/64 expansion for STRIP encoding,
* that translates to a maximum payload MTU of 1132.
*/
static const unsigned short MAX_STRIP_MTU = 1132;
static const unsigned short DEFAULT_STRIP_MTU = 1024;
static const int STRIP_MAGIC = 0x5303;
static const long LongTime = 0x7FFFFFFF;
static const int STRIP_NODE_LEN = 64;
static const char STRIP_PORTABLE_CHAR = 'P';
static const char STRIP_ROUTER_CHAR = 'r';
static const int STRIP_PROC_BUFFER_SIZE = 4096;
static const int STRIP_LOG_INT_SIZE = 10;
/************************************************************************/
/* Global variables */
static struct strip *struct_strip_list = NULL;
/************************************************************************/
/* Macros */
#define READHEX(X) ((X)>='0' && (X)<='9' ? (X)-'0' : \
(X)>='a' && (X)<='f' ? (X)-'a'+10 : \
(X)>='A' && (X)<='F' ? (X)-'A'+10 : 0 )
#define READDEC(X) ((X)>='0' && (X)<='9' ? (X)-'0' : 0)
#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
#define ELEMENTS_OF(X) (sizeof(X) / sizeof((X)[0]))
#define ARRAY_END(X) (&((X)[ELEMENTS_OF(X)]))
/* Encapsulation can expand packet of size x to 65/64x + 1 */
/* Sent packet looks like "*<address>*<key><encaps payload><CR>" */
/* 1 1-18 1 4 ? 1 */
/* We allow 31 bytes for the stars, the key, the address and the <CR> */
#define STRIP_ENCAP_SIZE(X) (32 + (X)*65L/64L)
#define IS_RADIO_ADDRESS(p) ( \
isdigit((p)[0]) && isdigit((p)[1]) && isdigit((p)[2]) && isdigit((p)[3]) && \
(p)[4] == '-' && \
isdigit((p)[5]) && isdigit((p)[6]) && isdigit((p)[7]) && isdigit((p)[8]) )
#define JIFFIE_TO_SEC(X) ((X) / HZ)
/************************************************************************/
/* Utility routines */
typedef unsigned long InterruptStatus;
extern __inline__ InterruptStatus DisableInterrupts(void)
{
InterruptStatus x;
save_flags(x);
cli();
return(x);
}
extern __inline__ void RestoreInterrupts(InterruptStatus x)
{
restore_flags(x);
}
static void DumpData(char *msg, struct strip *strip_info, __u8 *ptr, __u8 *end)
{
static const int MAX_DumpData = 80;
__u8 pkt_text[MAX_DumpData], *p = pkt_text;
*p++ = '\"';
while (ptr<end && p < &pkt_text[MAX_DumpData-4])
{
if (*ptr == '\\')
{
*p++ = '\\';
*p++ = '\\';
}
else
{
if (*ptr >= 32 && *ptr <= 126)
{
*p++ = *ptr;
}
else
{
sprintf(p, "\\%02X", *ptr);
p+= 3;
}
}
ptr++;
}
if (ptr == end)
{
*p++ = '\"';
}
*p++ = 0;
printk(KERN_INFO "%s: %-13s%s\n", strip_info->dev.name, msg, pkt_text);
}
#if 0
static void HexDump(char *msg, struct strip *strip_info, __u8 *start, __u8 *end)
{
__u8 *ptr = start;
printk(KERN_INFO "%s: %s: %d bytes\n", strip_info->dev.name, msg, end-ptr);
while (ptr < end)
{
long offset = ptr - start;
__u8 text[80], *p = text;
while (ptr < end && p < &text[16*3])
{
*p++ = hextable[*ptr >> 4];
*p++ = hextable[*ptr++ & 0xF];
*p++ = ' ';
}
p[-1] = 0;
printk(KERN_INFO "%s: %4lX %s\n", strip_info->dev.name, offset, text);
}
}
#endif
/************************************************************************/
/* Byte stuffing/unstuffing routines */
/* Stuffing scheme:
* 00 Unused (reserved character)
* 01-3F Run of 2-64 different characters
* 40-7F Run of 1-64 different characters plus a single zero at the end
* 80-BF Run of 1-64 of the same character
* C0-FF Run of 1-64 zeroes (ASCII 0)
*/
typedef enum
{
Stuff_Diff = 0x00,
Stuff_DiffZero = 0x40,
Stuff_Same = 0x80,
Stuff_Zero = 0xC0,
Stuff_NoCode = 0xFF, /* Special code, meaning no code selected */
Stuff_CodeMask = 0xC0,
Stuff_CountMask = 0x3F,
Stuff_MaxCount = 0x3F,
Stuff_Magic = 0x0D /* The value we are eliminating */
} StuffingCode;
/* StuffData encodes the data starting at "src" for "length" bytes.
* It writes it to the buffer pointed to by "dst" (which must be at least
* as long as 1 + 65/64 of the input length). The output may be up to 1.6%
* larger than the input for pathological input, but will usually be smaller.
* StuffData returns the new value of the dst pointer as its result.
* "code_ptr_ptr" points to a "__u8 *" which is used to hold encoding state
* between calls, allowing an encoded packet to be incrementally built up
* from small parts. On the first call, the "__u8 *" pointed to should be
* initialized to NULL; between subsequent calls the calling routine should
* leave the value alone and simply pass it back unchanged so that the
* encoder can recover its current state.
*/
#define StuffData_FinishBlock(X) \
(*code_ptr = (X) ^ Stuff_Magic, code = Stuff_NoCode)
static __u8 *StuffData(__u8 *src, __u32 length, __u8 *dst, __u8 **code_ptr_ptr)
{
__u8 *end = src + length;
__u8 *code_ptr = *code_ptr_ptr;
__u8 code = Stuff_NoCode, count = 0;
if (!length)
return(dst);
if (code_ptr)
{
/*
* Recover state from last call, if applicable
*/
code = (*code_ptr ^ Stuff_Magic) & Stuff_CodeMask;
count = (*code_ptr ^ Stuff_Magic) & Stuff_CountMask;
}
while (src < end)
{
switch (code)
{
/* Stuff_NoCode: If no current code, select one */
case Stuff_NoCode:
/* Record where we're going to put this code */
code_ptr = dst++;
count = 0; /* Reset the count (zero means one instance) */
/* Tentatively start a new block */
if (*src == 0)
{
code = Stuff_Zero;
src++;
}
else
{
code = Stuff_Same;
*dst++ = *src++ ^ Stuff_Magic;
}
/* Note: We optimistically assume run of same -- */
/* which will be fixed later in Stuff_Same */
/* if it turns out not to be true. */
break;
/* Stuff_Zero: We already have at least one zero encoded */
case Stuff_Zero:
/* If another zero, count it, else finish this code block */
if (*src == 0)
{
count++;
src++;
}
else
{
StuffData_FinishBlock(Stuff_Zero + count);
}
break;
/* Stuff_Same: We already have at least one byte encoded */
case Stuff_Same:
/* If another one the same, count it */
if ((*src ^ Stuff_Magic) == code_ptr[1])
{
count++;
src++;
break;
}
/* else, this byte does not match this block. */
/* If we already have two or more bytes encoded, finish this code block */
if (count)
{
StuffData_FinishBlock(Stuff_Same + count);
break;
}
/* else, we only have one so far, so switch to Stuff_Diff code */
code = Stuff_Diff;
/* and fall through to Stuff_Diff case below */
/* Stuff_Diff: We have at least two *different* bytes encoded */
case Stuff_Diff:
/* If this is a zero, must encode a Stuff_DiffZero, and begin a new block */
if (*src == 0)
{
StuffData_FinishBlock(Stuff_DiffZero + count);
}
/* else, if we have three in a row, it is worth starting a Stuff_Same block */
else if ((*src ^ Stuff_Magic)==dst[-1] && dst[-1]==dst[-2])
{
/* Back off the last two characters we encoded */
code += count-2;
/* Note: "Stuff_Diff + 0" is an illegal code */
if (code == Stuff_Diff + 0)
{
code = Stuff_Same + 0;
}
StuffData_FinishBlock(code);
code_ptr = dst-2;
/* dst[-1] already holds the correct value */
count = 2; /* 2 means three bytes encoded */
code = Stuff_Same;
}
/* else, another different byte, so add it to the block */
else
{
*dst++ = *src ^ Stuff_Magic;
count++;
}
src++; /* Consume the byte */
break;
}
if (count == Stuff_MaxCount)
{
StuffData_FinishBlock(code + count);
}
}
if (code == Stuff_NoCode)
{
*code_ptr_ptr = NULL;
}
else
{
*code_ptr_ptr = code_ptr;
StuffData_FinishBlock(code + count);
}
return(dst);
}
/*
* UnStuffData decodes the data at "src", up to (but not including) "end".
* It writes the decoded data into the buffer pointed to by "dst", up to a
* maximum of "dst_length", and returns the new value of "src" so that a
* follow-on call can read more data, continuing from where the first left off.
*
* There are three types of results:
* 1. The source data runs out before extracting "dst_length" bytes:
* UnStuffData returns NULL to indicate failure.
* 2. The source data produces exactly "dst_length" bytes:
* UnStuffData returns new_src = end to indicate that all bytes were consumed.
* 3. "dst_length" bytes are extracted, with more remaining.
* UnStuffData returns new_src < end to indicate that there are more bytes
* to be read.
*
* Note: The decoding may be destructive, in that it may alter the source
* data in the process of decoding it (this is necessary to allow a follow-on
* call to resume correctly).
*/
static __u8 *UnStuffData(__u8 *src, __u8 *end, __u8 *dst, __u32 dst_length)
{
__u8 *dst_end = dst + dst_length;
/* Sanity check */
if (!src || !end || !dst || !dst_length)
return(NULL);
while (src < end && dst < dst_end)
{
int count = (*src ^ Stuff_Magic) & Stuff_CountMask;
switch ((*src ^ Stuff_Magic) & Stuff_CodeMask)
{
case Stuff_Diff:
if (src+1+count >= end)
return(NULL);
do
{
*dst++ = *++src ^ Stuff_Magic;
}
while(--count >= 0 && dst < dst_end);
if (count < 0)
src += 1;
else
{
if (count == 0)
*src = Stuff_Same ^ Stuff_Magic;
else
*src = (Stuff_Diff + count) ^ Stuff_Magic;
}
break;
case Stuff_DiffZero:
if (src+1+count >= end)
return(NULL);
do
{
*dst++ = *++src ^ Stuff_Magic;
}
while(--count >= 0 && dst < dst_end);
if (count < 0)
*src = Stuff_Zero ^ Stuff_Magic;
else
*src = (Stuff_DiffZero + count) ^ Stuff_Magic;
break;
case Stuff_Same:
if (src+1 >= end)
return(NULL);
do
{
*dst++ = src[1] ^ Stuff_Magic;
}
while(--count >= 0 && dst < dst_end);
if (count < 0)
src += 2;
else
*src = (Stuff_Same + count) ^ Stuff_Magic;
break;
case Stuff_Zero:
do
{
*dst++ = 0;
}
while(--count >= 0 && dst < dst_end);
if (count < 0)
src += 1;
else
*src = (Stuff_Zero + count) ^ Stuff_Magic;
break;
}
}
if (dst < dst_end)
return(NULL);
else
return(src);
}
/************************************************************************/
/* General routines for STRIP */
/*
* Convert a string to a Metricom Address.
*/
static void string_to_radio_address(MetricomAddress *addr, __u8 *p)
{
addr->c[0] = 0;
addr->c[1] = 0;
addr->c[2] = READHEX(p[0]) << 4 | READHEX(p[1]);
addr->c[3] = READHEX(p[2]) << 4 | READHEX(p[3]);
addr->c[4] = READHEX(p[5]) << 4 | READHEX(p[6]);
addr->c[5] = READHEX(p[7]) << 4 | READHEX(p[8]);
}
/*
* Convert a Metricom Address to a string.
*/
static __u8 *radio_address_to_string(const MetricomAddress *addr, MetricomAddressString *p)
{
sprintf(p->c, "%02X%02X-%02X%02X", addr->c[2], addr->c[3], addr->c[4], addr->c[5]);
return(p->c);
}
/*
* Note: Must make sure sx_size is big enough to receive a stuffed
* MAX_STRIP_MTU packet. Additionally, we also want to ensure that it's
* big enough to receive a large radio neighbour list (currently 4K).
*/
static int allocate_buffers(struct strip *strip_info)
{
struct device *dev = &strip_info->dev;
int stuffedlen = STRIP_ENCAP_SIZE(dev->mtu);
int sx_size = MAX(stuffedlen, 4096);
int tx_size = stuffedlen + sizeof(TickleString2);
__u8 *r = kmalloc(MAX_STRIP_MTU, GFP_ATOMIC);
__u8 *s = kmalloc(sx_size, GFP_ATOMIC);
__u8 *t = kmalloc(tx_size, GFP_ATOMIC);
if (r && s && t)
{
strip_info->rx_buff = r;
strip_info->sx_buff = s;
strip_info->tx_buff = t;
strip_info->sx_size = sx_size;
strip_info->tx_size = tx_size;
strip_info->mtu = dev->mtu;
return(1);
}
if (r) kfree(r);
if (s) kfree(s);
if (t) kfree(t);
return(0);
}
/*
* MTU has been changed by the IP layer. Unfortunately we are not told
* about this, but we spot it ourselves and fix things up. We could be in
* an upcall from the tty driver, or in an ip packet queue.
*/
static void strip_changedmtu(struct strip *strip_info)
{
int old_mtu = strip_info->mtu;
struct device *dev = &strip_info->dev;
unsigned char *orbuff = strip_info->rx_buff;
unsigned char *osbuff = strip_info->sx_buff;
unsigned char *otbuff = strip_info->tx_buff;
InterruptStatus intstat;
if (dev->mtu > MAX_STRIP_MTU)
{
printk(KERN_ERR "%s: MTU exceeds maximum allowable (%d), MTU change cancelled.\n",
strip_info->dev.name, MAX_STRIP_MTU);
dev->mtu = old_mtu;
return;
}
/*
* Have to disable interrupts here because we're reallocating and resizing
* the serial buffers, and we can't have data arriving in them while we're
* moving them around in memory. This may cause data to be lost on the serial
* port, but hopefully people won't change MTU that often.
* Also note, this may not work on a symmetric multi-processor system.
*/
intstat = DisableInterrupts();
if (!allocate_buffers(strip_info))
{
RestoreInterrupts(intstat);
printk(KERN_ERR "%s: unable to grow strip buffers, MTU change cancelled.\n",
strip_info->dev.name);
dev->mtu = old_mtu;
return;
}
if (strip_info->sx_count)
{
if (strip_info->sx_count <= strip_info->sx_size)
memcpy(strip_info->sx_buff, osbuff, strip_info->sx_count);
else
{
strip_info->sx_count = 0;
strip_info->rx_over_errors++;
strip_info->discard = 1;
}
}
if (strip_info->tx_left)
{
if (strip_info->tx_left <= strip_info->tx_size)
memcpy(strip_info->tx_buff, strip_info->tx_head, strip_info->tx_left);
else
{
strip_info->tx_left = 0;
strip_info->tx_dropped++;
}
}
strip_info->tx_head = strip_info->tx_buff;
RestoreInterrupts(intstat);
printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
strip_info->dev.name, old_mtu, strip_info->mtu);
if (orbuff) kfree(orbuff);
if (osbuff) kfree(osbuff);
if (otbuff) kfree(otbuff);
}
static void strip_unlock(struct strip *strip_info)
{
/*
* Set the time to go off in one second.
*/
strip_info->idle_timer.expires = jiffies + HZ;
add_timer(&strip_info->idle_timer);
if (!clear_bit(0, (void *)&strip_info->dev.tbusy))
printk(KERN_ERR "%s: trying to unlock already unlocked device!\n",
strip_info->dev.name);
}
/************************************************************************/
/* Callback routines for exporting information through /proc */
#if DO_PROC_NET_STRIP_STATUS | DO_PROC_NET_STRIP_TRACE
/*
* This function updates the total amount of data printed so far. It then
* determines if the amount of data printed into a buffer has reached the
* offset requested. If it hasn't, then the buffer is shifted over so that
* the next bit of data can be printed over the old bit. If the total
* amount printed so far exceeds the total amount requested, then this
* function returns 1, otherwise 0.
*/
static int
shift_buffer(char *buffer, int requested_offset, int requested_len,
int *total, int *slop, char **buf)
{
int printed;
/* printk(KERN_DEBUG "shift: buffer: %d o: %d l: %d t: %d buf: %d\n",
(int) buffer, requested_offset, requested_len, *total,
(int) *buf); */
printed = *buf - buffer;
if (*total + printed <= requested_offset) {
*total += printed;
*buf = buffer;
}
else {
if (*total < requested_offset) {
*slop = requested_offset - *total;
}
*total = requested_offset + printed - *slop;
}
if (*total > requested_offset + requested_len) {
return 1;
}
else {
return 0;
}
}
/*
* This function calculates the actual start of the requested data
* in the buffer. It also calculates actual length of data returned,
* which could be less that the amount of data requested.
*/
static int
calc_start_len(char *buffer, char **start, int requested_offset,
int requested_len, int total, char *buf)
{
int return_len, buffer_len;
buffer_len = buf - buffer;
if (buffer_len >= STRIP_PROC_BUFFER_SIZE - 1) {
printk(KERN_ERR "STRIP: exceeded /proc buffer size\n");
}
/*
* There may be bytes before and after the
* chunk that was actually requested.
*/
return_len = total - requested_offset;
if (return_len < 0) {
return_len = 0;
}
*start = buf - return_len;
if (return_len > requested_len) {
return_len = requested_len;
}
/* printk(KERN_DEBUG "return_len: %d\n", return_len); */
return return_len;
}
#endif DO_PROC_NET_STRIP_STATUS | DO_PROC_NET_STRIP_TRACE
#if DO_PROC_NET_STRIP_STATUS
/*
* If the time is in the near future, time_delta prints the number of
* seconds to go into the buffer and returns the address of the buffer.
* If the time is not in the near future, it returns the address of the
* string "Not scheduled" The buffer must be long enough to contain the
* ascii representation of the number plus 9 charactes for the " seconds"
* and the null character.
*/
static char *time_delta(char buffer[], long time)
{
time -= jiffies;
if (time > LongTime / 2) return("Not scheduled");
if(time < 0) time = 0; /* Don't print negative times */
sprintf(buffer, "%ld seconds", time / HZ);
return(buffer);
}
/*
* This function prints radio status information into the specified
* buffer.
*/
static int
sprintf_status_info(char *buffer, struct strip *strip_info)
{
char temp_buffer[32];
MetricomAddressString addr_string;
char *buf;
buf = buffer;
buf += sprintf(buf, "Interface name\t\t%s\n", strip_info->if_name);
buf += sprintf(buf, " Radio working:\t\t%s\n",
strip_info->working &&
(long)jiffies - strip_info->watchdog_doreset < 0 ? "Yes" : "No");
(void) radio_address_to_string((MetricomAddress *)
&strip_info->dev.dev_addr,
&addr_string);
buf += sprintf(buf, " Device address:\t%s\n", addr_string.c);
buf += sprintf(buf, " Firmware version:\t%s\n",
!strip_info->working ? "Unknown" :
!strip_info->structured_messages ? "Should be upgraded" :
strip_info->firmware_version.c);
buf += sprintf(buf, " Serial number:\t\t%s\n", strip_info->serial_number.c);
buf += sprintf(buf, " Battery voltage:\t%s\n", strip_info->battery_voltage.c);
buf += sprintf(buf, " Transmit queue (bytes):%d\n", strip_info->tx_left);
buf += sprintf(buf, " Next watchdog probe:\t%s\n",
time_delta(temp_buffer, strip_info->watchdog_doprobe));
buf += sprintf(buf, " Next watchdog reset:\t%s\n",
time_delta(temp_buffer, strip_info->watchdog_doreset));
buf += sprintf(buf, " Next gratuitous ARP:\t%s\n",
time_delta(temp_buffer, strip_info->gratuitous_arp));
buf += sprintf(buf, " Next ARP interval:\t%ld seconds\n",
JIFFIE_TO_SEC(strip_info->arp_interval));
return buf - buffer;
}
static int
sprintf_portables(char *buffer, struct strip *strip_info)
{
MetricomAddressString addr_string;
MetricomNode *node;
char *buf;
buf = buffer;
buf += sprintf(buf, " portables: name\t\tpoll_latency\tsignal strength\n");
for (node = strip_info->neighbor_list; node != NULL;
node = node->next) {
if (!(node->type & NodeValid)) {
break;
}
if (node->type & NodeHasWAN) {
continue;
}
(void) radio_address_to_string(&node->addr, &addr_string);
buf += sprintf(buf, " %s\t\t\t\t%d\t\t%d\n",
addr_string.c, node->poll_latency, node->rssi);
}
return buf - buffer;
}
static int
sprintf_poletops(char *buffer, struct strip *strip_info)
{
MetricomNode *node;
char *buf;
buf = buffer;
buf += sprintf(buf, " poletops: GPS\t\t\tpoll_latency\tsignal strength\n");
for (node = strip_info->neighbor_list;
node != NULL; node = node->next) {
if (!(node->type & NodeValid)) {
break;
}
if (!(node->type & NodeHasWAN)) {
continue;
}
buf += sprintf(buf, " %s\t\t\t%d\t\t%d\n",
node->gl.s, node->poll_latency, node->rssi);
}
return buf - buffer;
}
/*
* This function is exports status information from the STRIP driver through
* the /proc file system. /proc filesystem should be fixed:
* 1) slow (sprintfs here, a memory copy in the proc that calls this one)
* 2) length of buffer not passed
* 3) dummy isn't client data set when the callback was registered
* 4) poorly documented (this function is called until the requested amount
* of data is returned, buffer is only 4K long, dummy is the permissions
* of the file (?), the proc_dir_entry passed to proc_net_register must
* be kmalloc-ed)
*/
static int
strip_get_status_info(char *buffer, char **start, off_t requested_offset,
int requested_len, int dummy)
{
char *buf;
int total = 0, slop = 0, len_exceeded;
InterruptStatus i_status;
struct strip *strip_info;
buf = buffer;
buf += sprintf(buf, "strip_version: %s\n", StripVersion);
i_status = DisableInterrupts();
strip_info = struct_strip_list;
RestoreInterrupts(i_status);
while (strip_info != NULL) {
i_status = DisableInterrupts();
buf += sprintf_status_info(buf, strip_info);
RestoreInterrupts(i_status);
len_exceeded = shift_buffer(buffer, requested_offset, requested_len,
&total, &slop, &buf);
if (len_exceeded) {
goto done;
}
strip_info->neighbor_list_locked = TRUE;
buf += sprintf_portables(buf, strip_info);
strip_info->neighbor_list_locked = FALSE;
len_exceeded = shift_buffer(buffer, requested_offset, requested_len,
&total, &slop, &buf);
if (len_exceeded) {
goto done;
}
strip_info->neighbor_list_locked = TRUE;
buf += sprintf_poletops(buf, strip_info);
strip_info->neighbor_list_locked = FALSE;
len_exceeded = shift_buffer(buffer, requested_offset, requested_len,
&total, &slop, &buf);
if (len_exceeded) {
goto done;
}
strip_info = strip_info->next;
}
done:
return calc_start_len(buffer, start, requested_offset, requested_len,
total, buf);
}
#endif DO_PROC_NET_STRIP_STATUS
#if DO_PROC_NET_STRIP_TRACE
/*
* Convert an Ethernet protocol to a string
* Returns the number of characters printed.
*/
static int protocol_to_string(int protocol, __u8 *p)
{
int printed;
switch (protocol) {
case ETH_P_IP:
printed = sprintf(p, "IP");
break;
case ETH_P_ARP:
printed = sprintf(p, "ARP");
break;
default:
printed = sprintf(p, "%d", protocol);
}
return printed;
}
static int
sprintf_log_entry(char *buffer, struct strip *strip_info, int packet_index)
{
StripLog *entry;
MetricomAddressString addr_string;
__u8 sig_buf[24], *s;
char *buf, proto_buf[10];
entry = &strip_info->packetLog[packet_index];
if (!entry->valid) {
return 0;
}
buf = buffer;
buf += sprintf(buf, "%-4s %s %7lu ", strip_info->if_name,
ENTRY_TYPE_TO_STRING(entry->entry_type), entry->seqNum);
(void) protocol_to_string(entry->packet_type, proto_buf);
buf += sprintf(buf, "%-4s", proto_buf);
s = entry->sig.print_sig;
sprintf(sig_buf, "%d.%d.%d.%d.%d.%d", s[0], s[1], s[2], s[3], s[4], s[5]);
buf += sprintf(buf, "%-24s", sig_buf);
(void) radio_address_to_string((MetricomAddress *) &entry->src,
&addr_string);
buf += sprintf(buf, "%-10s", addr_string.c);
(void) radio_address_to_string((MetricomAddress *) &entry->dest,
&addr_string);
buf += sprintf(buf, "%-10s", addr_string.c);
buf += sprintf(buf, "%8d %6d %5lu %6lu %5lu\n", entry->timeStamp.tv_sec,
entry->timeStamp.tv_usec, entry->rawSize,
entry->stripSize, entry->slipSize);
return buf - buffer;
}
/*
* This function exports trace information from the STRIP driver through the
* /proc file system.
*/
static int
strip_get_trace_info(char *buffer, char **start, off_t requested_offset,
int requested_len, int dummy)
{
char *buf;
int len_exceeded, total = 0, slop = 0, packet_index, oldest;
InterruptStatus i_status;
struct strip *strip_info;
buf = buffer;
buf += sprintf(buf, "if s/r seqnum t signature ");
buf += sprintf(buf,
"src dest sec usec raw strip slip\n");
i_status = DisableInterrupts();
strip_info = struct_strip_list;
oldest = strip_info->next_entry;
RestoreInterrupts(i_status);
/*
* If we disable interrupts for this entire loop,
* characters from the serial port could be lost,
* so we only disable interrupts when accessing
* a log entry. If more than STRIP_LOG_INT_SIZE
* packets are logged before the first entry is
* printed, then some of the entries could be
* printed out of order.
*/
while (strip_info != NULL) {
for (packet_index = oldest + STRIP_LOG_INT_SIZE;
packet_index != oldest;
packet_index = (packet_index + 1) %
ELEMENTS_OF(strip_info->packetLog)) {
i_status = DisableInterrupts();
buf += sprintf_log_entry(buf, strip_info, packet_index);
RestoreInterrupts(i_status);
len_exceeded = shift_buffer(buffer, requested_offset,
requested_len, &total, &slop, &buf);
if (len_exceeded) {
goto done;
}
}
strip_info = strip_info->next;
}
done:
return calc_start_len(buffer, start, requested_offset, requested_len,
total, buf);
}
static int slip_len(unsigned char *data, int len)
{
static const unsigned char SLIP_END=0300; /* indicates end of SLIP frame */
static const unsigned char SLIP_ESC=0333; /* indicates SLIP byte stuffing */
int count = len;
while (--len >= 0)
{
if (*data == SLIP_END || *data == SLIP_ESC) count++;
data++;
}
return(count);
}
/* Copied from kernel/sched.c */
static void jiffiestotimeval(unsigned long jiffies, struct timeval *value)
{
value->tv_usec = (jiffies % HZ) * (1000000.0 / HZ);
value->tv_sec = jiffies / HZ;
return;
}
/*
* This function logs a packet.
* A pointer to the packet itself is passed so that some of the data can be
* used to compute a signature. The pointer should point the the
* part of the packet following the STRIP_header.
*/
static void packet_log(struct strip *strip_info, __u8 *packet,
LogEntry entry_type, STRIP_Header *hdr,
int raw_size, int strip_size, int slip_size)
{
StripLog *entry;
struct iphdr *iphdr;
struct arphdr *arphdr;
entry = &strip_info->packetLog[strip_info->next_entry];
if (entry_type == EntrySend) {
entry->seqNum = strip_info->num_sent++;
}
else {
entry->seqNum = strip_info->num_received++;
}
entry->entry_type = entry_type;
entry->packet_type = ntohs(hdr->protocol);
switch (entry->packet_type) {
case ETH_P_IP:
/*
* The signature for IP is the sender's ip address and
* the identification field.
*/
iphdr = (struct iphdr *) packet;
entry->sig.ip_sig.id = iphdr->id;
entry->sig.ip_sig.src.l = iphdr->saddr;
break;
case ETH_P_ARP:
/*
* The signature for ARP is the sender's ip address and
* the operation.
*/
arphdr = (struct arphdr *) packet;
entry->sig.arp_sig.op = arphdr->ar_op;
memcpy(&entry->sig.arp_sig.src.l, packet + 8 + arphdr->ar_hln,
sizeof(entry->sig.arp_sig.src.l));
entry->sig.arp_sig.src.l = entry->sig.arp_sig.src.l;
break;
default:
printk(KERN_DEBUG "STRIP: packet_log: unknown packet type: %d\n",
entry->packet_type);
break;
}
memcpy(&entry->src, &hdr->src_addr, sizeof(MetricomAddress));
memcpy(&entry->dest, &hdr->dst_addr, sizeof(MetricomAddress));
jiffiestotimeval(jiffies, &(entry->timeStamp));
entry->rawSize = raw_size;
entry->stripSize = strip_size;
entry->slipSize = slip_size;
entry->valid = 1;
strip_info->next_entry = (strip_info->next_entry + 1) %
ELEMENTS_OF(strip_info->packetLog);
}
#endif DO_PROC_NET_STRIP_TRACE
/*
* This function parses the response to the ATS300? command,
* extracting the radio version and serial number.
*/
static void get_radio_version(struct strip *strip_info, __u8 *ptr, __u8 *end)
{
__u8 *p, *value_begin, *value_end;
int len;
/* Determine the beginning of the second line of the payload */
p = ptr;
while (p < end && *p != 10) p++;
if (p >= end) return;
p++;
value_begin = p;
/* Determine the end of line */
while (p < end && *p != 10) p++;
if (p >= end) return;
value_end = p;
p++;
len = value_end - value_begin;
len = MIN(len, sizeof(MetricomFirmwareVersion) - 1);
sprintf(strip_info->firmware_version.c, "%.*s", len, value_begin);
/* Look for the first colon */
while (p < end && *p != ':') p++;
if (p >= end) return;
/* Skip over the space */
p += 2;
len = sizeof(MetricomSerialNumber) - 1;
if (p + len <= end) {
sprintf(strip_info->serial_number.c, "%.*s", len, p);
}
else {
printk(KERN_ERR "STRIP: radio serial number shorter (%d) than expected (%d)\n",
end - p, len);
}
}
/*
* This function parses the response to the ATS325? command,
* extracting the radio battery voltage.
*/
static void get_radio_voltage(struct strip *strip_info, __u8 *ptr, __u8 *end)
{
int len;
len = sizeof(MetricomBatteryVoltage) - 1;
if (ptr + len <= end) {
sprintf(strip_info->battery_voltage.c, "%.*s", len, ptr);
}
else {
printk(KERN_ERR "STRIP: radio voltage string shorter (%d) than expected (%d)\n",
end - ptr, len);
}
}
/*
* This function parses the response to the AT~I2 command,
* which gives the names of the radio's nearest neighbors.
* It relies on the format of the response.
*/
static void get_radio_neighbors(struct strip *strip_info, __u8 *ptr, __u8 *end)
{
__u8 *p, *line_begin;
int num_nodes_reported, num_nodes_counted;
MetricomNode *node, *last;
/* Check if someone is reading the list */
if (strip_info->neighbor_list_locked) {
return;
}
/* Determine the number of Nodes */
p = ptr;
num_nodes_reported = simple_strtoul(p, NULL, 10);
/* printk(KERN_DEBUG "num_nodes: %d\n", num_nodes_reported); */
/* Determine the beginning of the next line */
while (p < end && *p != 10) p++;
if (p >= end) return;
p++;
/*
* The node list should never be empty because we allocate one empty
* node when the strip_info is allocated. The nodes which were allocated
* when the number of neighbors was high but are no longer needed because
* there aren't as many neighbors any more are marked invalid. Invalid nodes
* are kept at the end of the list.
*/
node = strip_info->neighbor_list;
last = node;
if (node == NULL) {
DumpData("Neighbor list is NULL:", strip_info, p, end);
return;
}
line_begin = p;
num_nodes_counted = 0;
while (line_begin < end) {
/* Check to see if the format is what we expect. */
if ((line_begin + STRIP_NODE_LEN) > end) {
printk(KERN_ERR "STRIP: radio neighbor node string shorter (%d) than expected (%d)\n",
end - line_begin, STRIP_NODE_LEN);
break;
}
/* Get a node */
if (node == NULL) {
node = kmalloc(sizeof(MetricomNode), GFP_ATOMIC);
node->next = NULL;
}
node->type = NodeValid;
/* Fill the node in */
/* Determine if it has a GPS location and fill it in if it does. */
p = line_begin;
/* printk(KERN_DEBUG "node: %64s\n", p); */
if (p[0] != STRIP_PORTABLE_CHAR) {
node->type |= NodeHasWAN;
sprintf(node->gl.s, "%.*s", (int) sizeof(GeographicLocation) - 1, p);
}
/* Determine if it is a router */
p = line_begin + 18;
if (p[0] == STRIP_ROUTER_CHAR) {
node->type |= NodeIsRouter;
}
/* Could be a radio address or some weird poletop address. */
p = line_begin + 20;
/* printk(KERN_DEBUG "before addr: %6s\n", p); */
string_to_radio_address(&node->addr, p);
/* radio_address_to_string(&node->addr, addr_string);
printk(KERN_DEBUG "after addr: %s\n", addr_string); */
if (IS_RADIO_ADDRESS(p)) {
string_to_radio_address(&node->addr, p);
}
else {
memset(&node->addr, 0, sizeof(MetricomAddress));
}
/* Get the poll latency. %$#!@ simple_strtoul can't skip white space */
p = line_begin + 41;
while (isspace(*p) && (p < end)) {
p++;
}
node->poll_latency = simple_strtoul(p, NULL, 10);
/* Get the signal strength. simple_strtoul doesn't do minus signs */
p = line_begin + 60;
node->rssi = -simple_strtoul(p, NULL, 10);
if (last != node) {
last->next = node;
last = node;
}
node = node->next;
line_begin += STRIP_NODE_LEN;
num_nodes_counted++;
}
/* invalidate all remaining nodes */
for (;node != NULL; node = node->next) {
node->type &= ~NodeValid;
}
/*
* If the number of nodes reported is different
* from the number counted, might need to up the number
* requested.
*/
if (num_nodes_reported != num_nodes_counted) {
printk(KERN_DEBUG "nodes reported: %d \tnodes counted: %d\n",
num_nodes_reported, num_nodes_counted);
}
}
/************************************************************************/
/* Sending routines */
static void ResetRadio(struct strip *strip_info)
{
static const char InitString[] = "\rat\r\rate0q1dt**starmode\r\r**";
/* If the radio isn't working anymore, we should clear the old status information. */
if (strip_info->working)
{
printk(KERN_INFO "%s: No response: Resetting radio.\n", strip_info->dev.name);
strip_info->firmware_version.c[0] = '\0';
strip_info->serial_number.c[0] = '\0';
strip_info->battery_voltage.c[0] = '\0';
}
/* Mark radio address as unknown */
*(MetricomAddress*)&strip_info->dev.dev_addr = zero_address;
strip_info->working = FALSE;
strip_info->structured_messages = FALSE;
strip_info->watchdog_doprobe = jiffies + 10 * HZ;
strip_info->watchdog_doreset = jiffies + 1 * HZ;
strip_info->tty->driver.write(strip_info->tty, 0, (char *)InitString, sizeof(InitString)-1);
}
/*
* Called by the driver when there's room for more data. If we have
* more packets to send, we send them here.
*/
static void strip_write_some_more(struct tty_struct *tty)
{
struct strip *strip_info = (struct strip *) tty->disc_data;
/* First make sure we're connected. */
if (!strip_info || strip_info->magic != STRIP_MAGIC || !strip_info->dev.start)
return;
if (strip_info->tx_left > 0)
{
/*
* If some data left, send it
* Note: There's a kernel design bug here. The write_wakeup routine has to
* know how many bytes were written in the previous call, but the number of
* bytes written is returned as the result of the tty->driver.write call,
* and there's no guarantee that the tty->driver.write routine will have
* returned before the write_wakeup routine is invoked. If the PC has fast
* Serial DMA hardware, then it's quite possible that the write could complete
* almost instantaneously, meaning that my write_wakeup routine could be
* called immediately, before tty->driver.write has had a chance to return
* the number of bytes that it wrote. In an attempt to guard against this,
* I disable interrupts around the call to tty->driver.write, although even
* this might not work on a symmetric multi-processor system.
*/
InterruptStatus intstat = DisableInterrupts();
int num_written = tty->driver.write(tty, 0, strip_info->tx_head, strip_info->tx_left);
strip_info->tx_left -= num_written;
strip_info->tx_head += num_written;
RestoreInterrupts(intstat);
}
else /* Else start transmission of another packet */
{
tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
strip_unlock(strip_info);
mark_bh(NET_BH);
}
}
static unsigned char *strip_make_packet(unsigned char *ptr, struct strip *strip_info, struct sk_buff *skb)
{
#if DO_PROC_NET_STRIP_TRACE
unsigned char *start_ptr;
#endif DO_PROC_NET_STRIP_TRACE
__u8 *stuffstate = NULL;
STRIP_Header *header = (STRIP_Header *)skb->data;
MetricomAddress haddr = header->dst_addr;
int len = skb->len - sizeof(STRIP_Header);
MetricomKey key;
/*HexDump("strip_make_packet", strip_info, skb->data, skb->data + skb->len);*/
if (header->protocol == htons(ETH_P_IP)) key = SIP0Key;
else if (header->protocol == htons(ETH_P_ARP)) key = ARP0Key;
else
{
printk(KERN_ERR "%s: strip_make_packet: Unknown packet type 0x%04X\n",
strip_info->dev.name, ntohs(header->protocol));
strip_info->tx_dropped++;
return(NULL);
}
if (len > strip_info->mtu)
{
printk(KERN_ERR "%s: Dropping oversized transmit packet: %d bytes\n",
strip_info->dev.name, len);
strip_info->tx_dropped++;
return(NULL);
}
/*
* If this is a broadcast packet, send it to our designated Metricom
* 'broadcast hub' radio (First byte of address being 0xFF means broadcast)
*/
if (haddr.c[0] == 0xFF)
{
/*IPaddr a;
a.l = strip_info->dev.pa_brdaddr;
printk(KERN_INFO "%s: Broadcast packet! Sending to %d.%d.%d.%d\n",
strip_info->dev.name, a.b[0], a.b[1], a.b[2], a.b[3]);*/
if (!arp_query(haddr.c, strip_info->dev.pa_brdaddr, &strip_info->dev))
{
/*IPaddr a;
a.l = strip_info->dev.pa_brdaddr;
printk(KERN_INFO "%s: No ARP cache entry for %d.%d.%d.%d\n",
strip_info->dev.name, a.b[0], a.b[1], a.b[2], a.b[3]);
strip_info->tx_dropped++;*/
return(NULL);
}
}
*ptr++ = '*';
*ptr++ = hextable[haddr.c[2] >> 4];
*ptr++ = hextable[haddr.c[2] & 0xF];
*ptr++ = hextable[haddr.c[3] >> 4];
*ptr++ = hextable[haddr.c[3] & 0xF];
*ptr++ = '-';
*ptr++ = hextable[haddr.c[4] >> 4];
*ptr++ = hextable[haddr.c[4] & 0xF];
*ptr++ = hextable[haddr.c[5] >> 4];
*ptr++ = hextable[haddr.c[5] & 0xF];
*ptr++ = '*';
*ptr++ = key.c[0];
*ptr++ = key.c[1];
*ptr++ = key.c[2];
*ptr++ = key.c[3];
#if DO_PROC_NET_STRIP_TRACE
start_ptr = ptr;
#endif DO_PROC_NET_STRIP_TRACE
ptr = StuffData(skb->data + sizeof(STRIP_Header), len, ptr, &stuffstate);
#if DO_PROC_NET_STRIP_TRACE
packet_log(strip_info, skb->data + sizeof(STRIP_Header), EntrySend,
header, len, ptr-start_ptr,
slip_len(skb->data + sizeof(STRIP_Header), len));
#endif DO_PROC_NET_STRIP_TRACE
*ptr++ = 0x0D;
return(ptr);
}
static void strip_send(struct strip *strip_info, struct sk_buff *skb)
{
unsigned char *ptr = strip_info->tx_buff;
/* If we have a packet, encapsulate it and put it in the buffer */
if (skb)
{
ptr = strip_make_packet(ptr, strip_info, skb);
/* If error, unlock and return */
if (!ptr) { strip_unlock(strip_info); return; }
strip_info->tx_packets++; /* Count another successful packet */
/*DumpData("Sending:", strip_info, strip_info->tx_buff, ptr);*/
/*HexDump("Sending", strip_info, strip_info->tx_buff, ptr);*/
}
/* Set up the strip_info ready to send the data */
strip_info->tx_head = strip_info->tx_buff;
strip_info->tx_left = ptr - strip_info->tx_buff;
strip_info->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
/* If watchdog has expired, reset the radio */
if ((long)jiffies - strip_info->watchdog_doreset >= 0)
{
ResetRadio(strip_info);
return;
/* Note: if there's a packet to send, strip_write_some_more
will do it after the reset has finished */
}
/* No reset.
* If it is time for another tickle, tack it on the end of the packet
*/
if ((long)jiffies - strip_info->watchdog_doprobe >= 0)
{
/* Send tickle to make radio protest */
/*printk(KERN_INFO "%s: Routine radio test.\n", strip_info->dev.name);*/
const char *TickleString = TickleString1;
int length = sizeof(TickleString1)-1;
if (strip_info->structured_messages)
{
TickleString = TickleString2;
length = sizeof(TickleString2)-1;
}
memcpy(ptr, TickleString, length);
strip_info->tx_left += length;
strip_info->watchdog_doprobe = jiffies + 10 * HZ;
strip_info->watchdog_doreset = jiffies + 1 * HZ;
}
/*
* If it is time for a periodic ARP, queue one up to be sent
*/
if (strip_info->working && (long)jiffies - strip_info->gratuitous_arp >= 0 &&
memcmp(strip_info->dev.dev_addr, zero_address.c, sizeof(zero_address)))
{
/*printk(KERN_INFO "%s: Sending gratuitous ARP with interval %ld\n",
strip_info->dev.name, strip_info->arp_interval / HZ);*/
strip_info->gratuitous_arp = jiffies + strip_info->arp_interval;
strip_info->arp_interval *= 2;
if (strip_info->arp_interval > MaxARPInterval)
strip_info->arp_interval = MaxARPInterval;
arp_send(ARPOP_REPLY, ETH_P_ARP, strip_info->dev.pa_addr,
&strip_info->dev, strip_info->dev.pa_addr,
NULL, strip_info->dev.dev_addr, NULL);
}
if (strip_info->tx_size - strip_info->tx_left < 20)
printk(KERN_ERR "%s: Sending%5d bytes;%5d bytes free.\n", strip_info->dev.name,
strip_info->tx_left, strip_info->tx_size - strip_info->tx_left);
/* All ready. Start the transmission */
strip_write_some_more(strip_info->tty);
}
/* Encapsulate a datagram and kick it into a TTY queue. */
static int strip_xmit(struct sk_buff *skb, struct device *dev)
{
struct strip *strip_info = (struct strip *)(dev->priv);
if (!dev->start)
{
printk(KERN_ERR "%s: xmit call when iface is down\n", dev->name);
return(1);
}
if (set_bit(0, (void *) &strip_info->dev.tbusy)) return(1);
del_timer(&strip_info->idle_timer);
/* See if someone has been ifconfigging */
if (strip_info->mtu != strip_info->dev.mtu)
strip_changedmtu(strip_info);
strip_send(strip_info, skb);
if (skb) dev_kfree_skb(skb, FREE_WRITE);
return(0);
}
/*
* Create the MAC header for an arbitrary protocol layer
*
* saddr!=NULL means use this specific address (n/a for Metricom)
* saddr==NULL means use default device source address
* daddr!=NULL means use this destination address
* daddr==NULL means leave destination address alone
* (e.g. unresolved arp -- kernel will call
* rebuild_header later to fill in the address)
*/
static int strip_header(struct sk_buff *skb, struct device *dev,
unsigned short type, void *daddr, void *saddr, unsigned len)
{
STRIP_Header *header = (STRIP_Header *)skb_push(skb, sizeof(STRIP_Header));
/*printk(KERN_INFO "%s: strip_header 0x%04X %s\n", dev->name, type,
type == ETH_P_IP ? "IP" : type == ETH_P_ARP ? "ARP" : "");*/
memcpy(header->src_addr.c, dev->dev_addr, dev->addr_len);
header->protocol = htons(type);
/*HexDump("strip_header", (struct strip *)(dev->priv), skb->data, skb->data + skb->len);*/
if (!daddr) return(-dev->hard_header_len);
memcpy(header->dst_addr.c, daddr, dev->addr_len);
return(dev->hard_header_len);
}
/*
* Rebuild the MAC header. This is called after an ARP
* (or in future other address resolution) has completed on this
* sk_buff. We now let ARP fill in the other fields.
* I think this should return zero if packet is ready to send,
* or non-zero if it needs more time to do an address lookup
*/
static int strip_rebuild_header(void *buff, struct device *dev,
unsigned long dst, struct sk_buff *skb)
{
STRIP_Header *header = (STRIP_Header *)buff;
/*printk(KERN_INFO "%s: strip_rebuild_header\n", dev->name);*/
#ifdef CONFIG_INET
/* Arp find returns zero if if knows the address, */
/* or if it doesn't know the address it sends an ARP packet and returns non-zero */
return arp_find(header->dst_addr.c, dst, dev, dev->pa_addr, skb)? 1 : 0;
#else
return 0;
#endif
}
/*
* IdleTask periodically calls strip_xmit, so even when we have no IP packets
* to send for an extended period of time, the watchdog processing still gets
* done to ensure that the radio stays in Starmode
*/
static void strip_IdleTask(unsigned long parameter)
{
strip_xmit(NULL, (struct device *)parameter);
}
/************************************************************************/
/* Receiving routines */
static int strip_receive_room(struct tty_struct *tty)
{
return 0x10000; /* We can handle an infinite amount of data. :-) */
}
static void get_radio_address(struct strip *strip_info, __u8 *p)
{
MetricomAddress addr;
string_to_radio_address(&addr, p);
/* See if our radio address has changed */
if (memcmp(strip_info->dev.dev_addr, addr.c, sizeof(addr)))
{
MetricomAddressString addr_string;
radio_address_to_string(&addr, &addr_string);
printk(KERN_INFO "%s: My radio address = %s\n", strip_info->dev.name, addr_string.c);
memcpy(strip_info->dev.dev_addr, addr.c, sizeof(addr));
/* Give the radio a few seconds to get its head straight, then send an arp */
strip_info->gratuitous_arp = jiffies + 6 * HZ;
strip_info->arp_interval = 1 * HZ;
}
}
static void RecvErr(char *msg, struct strip *strip_info)
{
__u8 *ptr = strip_info->sx_buff;
__u8 *end = strip_info->sx_buff + strip_info->sx_count;
DumpData(msg, strip_info, ptr, end);
strip_info->rx_errors++;
}
static void RecvErr_Message(struct strip *strip_info, __u8 *sendername, const __u8 *msg)
{
static const char ERR_001[] = "001"; /* Not in StarMode! */
static const char ERR_002[] = "002"; /* Remap handle */
static const char ERR_003[] = "003"; /* Can't resolve name */
static const char ERR_004[] = "004"; /* Name too small or missing */
static const char ERR_005[] = "005"; /* Bad count specification */
static const char ERR_006[] = "006"; /* Header too big */
static const char ERR_007[] = "007"; /* Body too big */
static const char ERR_008[] = "008"; /* Bad character in name */
static const char ERR_009[] = "009"; /* No count or line terminator */
if (!strncmp(msg, ERR_001, sizeof(ERR_001)-1))
{
RecvErr("Error Msg:", strip_info);
printk(KERN_INFO "%s: Radio %s is not in StarMode\n",
strip_info->dev.name, sendername);
}
else if (!strncmp(msg, ERR_002, sizeof(ERR_002)-1))
{
RecvErr("Error Msg:", strip_info);
#ifdef notyet /*Kernel doesn't have scanf!*/
int handle;
__u8 newname[64];
sscanf(msg, "ERR_002 Remap handle &%d to name %s", &handle, newname);
printk(KERN_INFO "%s: Radio name %s is handle %d\n",
strip_info->dev.name, newname, handle);
#endif
}
else if (!strncmp(msg, ERR_003, sizeof(ERR_003)-1))
{
RecvErr("Error Msg:", strip_info);
printk(KERN_INFO "%s: Destination radio name is unknown\n",
strip_info->dev.name);
}
else if (!strncmp(msg, ERR_004, sizeof(ERR_004)-1))
{
strip_info->watchdog_doreset = jiffies + LongTime;
if (!strip_info->working)
{
strip_info->working = TRUE;
printk(KERN_INFO "%s: Radio now in starmode\n",
strip_info->dev.name);
/*
* If the radio has just entered a working state, we should do our first
* probe ASAP, so that we find out our radio address etc. without delay.
*/
strip_info->watchdog_doprobe = jiffies;
}
if (!strip_info->structured_messages && sendername)
{
strip_info->structured_messages = TRUE;
printk(KERN_INFO "%s: Radio provides structured messages\n",
strip_info->dev.name);
}
}
else if (!strncmp(msg, ERR_005, sizeof(ERR_005)-1))
RecvErr("Error Msg:", strip_info);
else if (!strncmp(msg, ERR_006, sizeof(ERR_006)-1))
RecvErr("Error Msg:", strip_info);
else if (!strncmp(msg, ERR_007, sizeof(ERR_007)-1))
{
/*
* Note: This error knocks the radio back into
* command mode.
*/
RecvErr("Error Msg:", strip_info);
printk(KERN_ERR "%s: Error! Packet size too big for radio.",
strip_info->dev.name);
strip_info->watchdog_doreset = jiffies; /* Do reset ASAP */
}
else if (!strncmp(msg, ERR_008, sizeof(ERR_008)-1))
{
RecvErr("Error Msg:", strip_info);
printk(KERN_ERR "%s: Radio name contains illegal character\n",
strip_info->dev.name);
}
else if (!strncmp(msg, ERR_009, sizeof(ERR_009)-1))
RecvErr("Error Msg:", strip_info);
else
RecvErr("Error Msg:", strip_info);
}
static void process_AT_response(struct strip *strip_info, __u8 *ptr, __u8 *end)
{
static const char ATS305[] = "ATS305?";
static const char ATS300[] = "ATS300?";
static const char ATS325[] = "ATS325?";
static const char ATI2[] = "AT~I2 nn";
/* Skip to the first newline character */
__u8 *p = ptr;
while (p < end && *p != 10) p++;
if (p >= end) return;
p++;
if (!strncmp(ptr, ATS305, sizeof(ATS305)-1))
{
if (IS_RADIO_ADDRESS(p)) get_radio_address(strip_info, p);
}
else if (!strncmp(ptr, ATS300, sizeof(ATS300)-1)) {
get_radio_version(strip_info, p, end);
}
else if (!strncmp(ptr, ATS325, sizeof(ATS325)-1)) {
get_radio_voltage(strip_info, p, end);
}
else if (!strncmp(ptr, ATI2, sizeof(ATI2)-1)) {
get_radio_neighbors(strip_info, p, end);
}
else RecvErr("Unknown AT Response:", strip_info);
}
/*
* Send one completely decapsulated datagram to the next layer.
*/
static void deliver_packet(struct strip *strip_info, STRIP_Header *header, __u16 packetlen)
{
struct sk_buff *skb = dev_alloc_skb(sizeof(STRIP_Header) + packetlen);
if (!skb)
{
printk(KERN_INFO "%s: memory squeeze, dropping packet.\n", strip_info->dev.name);
strip_info->rx_dropped++;
}
else
{
memcpy(skb_put(skb, sizeof(STRIP_Header)), header, sizeof(STRIP_Header));
memcpy(skb_put(skb, packetlen), strip_info->rx_buff, packetlen);
skb->dev = &strip_info->dev;
skb->protocol = header->protocol;
skb->mac.raw = skb->data;
/* Having put a fake header on the front of the sk_buff for the */
/* benefit of tools like tcpdump, skb_pull now 'consumes' that */
/* fake header before we hand the packet up to the next layer. */
skb_pull(skb, sizeof(STRIP_Header));
/* Finally, hand the packet up to the next layer (e.g. IP or ARP, etc.) */
strip_info->rx_packets++;
netif_rx(skb);
}
}
static void process_IP_packet(struct strip *strip_info, STRIP_Header *header, __u8 *ptr, __u8 *end)
{
__u16 packetlen;
#if DO_PROC_NET_STRIP_TRACE
__u8 *start_ptr = ptr;
#endif DO_PROC_NET_STRIP_TRACE
/* Decode start of the IP packet header */
ptr = UnStuffData(ptr, end, strip_info->rx_buff, 4);
if (!ptr)
{
RecvErr("IP Packet too short", strip_info);
return;
}
packetlen = ((__u16)strip_info->rx_buff[2] << 8) | strip_info->rx_buff[3];
if (packetlen > MAX_STRIP_MTU)
{
printk(KERN_ERR "%s: Dropping oversized receive packet: %d bytes\n",
strip_info->dev.name, packetlen);
strip_info->rx_dropped++;
return;
}
/*printk(KERN_INFO "%s: Got %d byte IP packet\n", strip_info->dev.name, packetlen);*/
/* Decode remainder of the IP packet */
ptr = UnStuffData(ptr, end, strip_info->rx_buff+4, packetlen-4);
if (!ptr)
{
RecvErr("IP Packet too short", strip_info);
return;
}
if (ptr < end)
{
RecvErr("IP Packet too long", strip_info);
return;
}
header->protocol = htons(ETH_P_IP);
#if DO_PROC_NET_STRIP_TRACE
packet_log(strip_info, strip_info->rx_buff, EntryReceive, header,
packetlen, end-start_ptr, slip_len(strip_info->rx_buff, packetlen));
#endif DO_PROC_NET_STRIP_TRACE
deliver_packet(strip_info, header, packetlen);
}
static void process_ARP_packet(struct strip *strip_info, STRIP_Header *header, __u8 *ptr, __u8 *end)
{
__u16 packetlen;
struct arphdr *arphdr = (struct arphdr *)strip_info->rx_buff;
#if DO_PROC_NET_STRIP_TRACE
__u8 *start_ptr = ptr;
#endif DO_PROC_NET_STRIP_TRACE
/* Decode start of the ARP packet */
ptr = UnStuffData(ptr, end, strip_info->rx_buff, 8);
if (!ptr)
{
RecvErr("ARP Packet too short", strip_info);
return;
}
packetlen = 8 + (arphdr->ar_hln + arphdr->ar_pln) * 2;
if (packetlen > MAX_STRIP_MTU)
{
printk(KERN_ERR "%s: Dropping oversized receive packet: %d bytes\n",
strip_info->dev.name, packetlen);
strip_info->rx_dropped++;
return;
}
/*printk(KERN_INFO "%s: Got %d byte ARP %s\n",
strip_info->dev.name, packetlen,
ntohs(arphdr->ar_op) == ARPOP_REQUEST ? "request" : "reply");*/
/* Decode remainder of the ARP packet */
ptr = UnStuffData(ptr, end, strip_info->rx_buff+8, packetlen-8);
if (!ptr)
{
RecvErr("ARP Packet too short", strip_info);
return;
}
if (ptr < end)
{
RecvErr("ARP Packet too long", strip_info);
return;
}
header->protocol = htons(ETH_P_ARP);
#if DO_PROC_NET_STRIP_TRACE
packet_log(strip_info, strip_info->rx_buff, EntryReceive, header,
packetlen, end-start_ptr, slip_len(strip_info->rx_buff, packetlen));
#endif DO_PROC_NET_STRIP_TRACE
deliver_packet(strip_info, header, packetlen);
}
static void process_packet(struct strip *strip_info)
{
STRIP_Header header = { zero_address, zero_address, 0 };
__u8 *ptr = strip_info->sx_buff;
__u8 *end = strip_info->sx_buff + strip_info->sx_count;
__u8 sendername[32], *sptr = sendername;
MetricomKey key;
/* Ignore 'OK' responses from prior commands */
if (strip_info->sx_count == 2 && ptr[0] == 'O' && ptr[1] == 'K') return;
/* Check for anything that looks like it might be our radio name: dddd-dddd */
/* (This is here for backwards compatibility with old firmware) */
if (strip_info->sx_count == 9 && IS_RADIO_ADDRESS(ptr))
{
get_radio_address(strip_info, ptr);
return;
}
/*HexDump("Receiving", strip_info, ptr, end);*/
/* Check for start of address marker, and then skip over it */
if (*ptr != '*')
{
/* Catch other error messages */
if (ptr[0] == 'E' && ptr[1] == 'R' && ptr[2] == 'R' && ptr[3] == '_')
RecvErr_Message(strip_info, NULL, &ptr[4]);
else RecvErr("No initial *", strip_info);
return;
}
ptr++; /* Skip the initial '*' */
/* Copy out the return address */
while (ptr < end && *ptr != '*' && sptr < ARRAY_END(sendername)-1) *sptr++ = *ptr++;
*sptr = 0; /* Null terminate the sender name */
/* Check for end of address marker, and skip over it */
if (ptr >= end || *ptr != '*')
{
RecvErr("No second *", strip_info);
return;
}
ptr++; /* Skip the second '*' */
/* If the sender name is "&COMMAND", ignore this 'packet' */
/* (This is here for backwards compatibility with old firmware) */
if (!strcmp(sendername, "&COMMAND"))
{
strip_info->structured_messages = FALSE;
return;
}
if (ptr+4 >= end)
{
RecvErr("No proto key", strip_info);
return;
}
/*printk(KERN_INFO "%s: Got packet from \"%s\".\n", strip_info->dev.name, sendername);*/
/*
* Fill in (pseudo) source and destination addresses in the packet.
* We assume that the destination address was our address (the radio does not
* tell us this). If the radio supplies a source address, then we use it.
*/
memcpy(&header.dst_addr, strip_info->dev.dev_addr, sizeof(MetricomAddress));
if (IS_RADIO_ADDRESS(sendername)) string_to_radio_address(&header.src_addr, sendername);
/* Get the protocol key out of the buffer */
key.c[0] = *ptr++;
key.c[1] = *ptr++;
key.c[2] = *ptr++;
key.c[3] = *ptr++;
if (key.l == SIP0Key.l) process_IP_packet(strip_info, &header, ptr, end);
else if (key.l == ARP0Key.l) process_ARP_packet(strip_info, &header, ptr, end);
else if (key.l == ATR_Key.l) process_AT_response(strip_info, ptr, end);
else if (key.l == ERR_Key.l) RecvErr_Message(strip_info, sendername, ptr);
else /* RecvErr("Unrecognized protocol key", strip_info); */
/* Note, this "else" block is temporary, until Metricom fix their */
/* packet corruption bug */
{
RecvErr("Unrecognized protocol key (retrying)", strip_info);
ptr -= 3; /* Back up and try again */
key.c[0] = *ptr++;
key.c[1] = *ptr++;
key.c[2] = *ptr++;
key.c[3] = *ptr++;
if (key.l == SIP0Key.l) process_IP_packet(strip_info, &header, ptr, end);
else if (key.l == ARP0Key.l) process_ARP_packet(strip_info, &header, ptr, end);
else if (key.l == ATR_Key.l) process_AT_response(strip_info, ptr, end);
else if (key.l == ERR_Key.l) RecvErr_Message(strip_info, sendername, ptr);
else RecvErr("Unrecognized protocol key", strip_info);
}
}
/*
* Handle the 'receiver data ready' interrupt.
* This function is called by the 'tty_io' module in the kernel when
* a block of STRIP data has been received, which can now be decapsulated
* and sent on to some IP layer for further processing.
*/
static void
strip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
{
struct strip *strip_info = (struct strip *) tty->disc_data;
const unsigned char *end = cp + count;
if (!strip_info || strip_info->magic != STRIP_MAGIC || !strip_info->dev.start)
return;
/* Argh! mtu change time! - costs us the packet part received at the change */
if (strip_info->mtu != strip_info->dev.mtu)
strip_changedmtu(strip_info);
#if 0
{
struct timeval tv;
do_gettimeofday(&tv);
printk(KERN_INFO "**** strip_receive_buf: %3d bytes at %d.%06d\n",
count, tv.tv_sec % 100, tv.tv_usec);
}
#endif
/* Read the characters out of the buffer */
while (cp < end)
{
if (fp && *fp++ && !strip_info->discard) /* If there's a serial error, record it */
{
strip_info->discard = 1;
strip_info->rx_errors++;
}
/* Leading control characters (CR, NL, Tab, etc.) are ignored */
if (strip_info->sx_count > 0 || *cp >= ' ')
{
if (*cp == 0x0D) /* If end of packet, decide what to do with it */
{
if (strip_info->sx_count > 3000)
printk(KERN_INFO "Cut a %d byte packet (%d bytes remaining)%s\n",
strip_info->sx_count, end-cp-1,
strip_info->discard ? " (discarded)" : "");
if (strip_info->sx_count > strip_info->sx_size)
{
strip_info->discard = 1;
strip_info->rx_over_errors++;
printk(KERN_INFO "%s: sx_buff overflow (%d bytes total)\n",
strip_info->dev.name, strip_info->sx_count);
}
if (!strip_info->discard) process_packet(strip_info);
strip_info->discard = 0;
strip_info->sx_count = 0;
}
else if (!strip_info->discard) /* If we're not discarding, store the character */
{
/* Make sure we have space in the buffer */
if (strip_info->sx_count < strip_info->sx_size)
strip_info->sx_buff[strip_info->sx_count] = *cp;
strip_info->sx_count++;
}
}
cp++;
}
}
/************************************************************************/
/* General control routines */
static int strip_set_dev_mac_address(struct device *dev, void *addr)
{
return -1; /* You cannot override a Metricom radio's address */
}
static struct enet_statistics *strip_get_stats(struct device *dev)
{
static struct enet_statistics stats;
struct strip *strip_info = (struct strip *)(dev->priv);
memset(&stats, 0, sizeof(struct enet_statistics));
stats.rx_packets = strip_info->rx_packets;
stats.tx_packets = strip_info->tx_packets;
stats.rx_dropped = strip_info->rx_dropped;
stats.tx_dropped = strip_info->tx_dropped;
stats.tx_errors = strip_info->tx_errors;
stats.rx_errors = strip_info->rx_errors;
stats.rx_over_errors = strip_info->rx_over_errors;
return(&stats);
}
/************************************************************************/
/* Opening and closing */
/*
* Here's the order things happen:
* When the user runs "slattach -p strip ..."
* 1. The TTY module calls strip_open
* 2. strip_open calls strip_alloc
* 3. strip_alloc calls register_netdev
* 4. register_netdev calls strip_dev_init
* 5. then strip_open finishes setting up the strip_info
*
* When the user runs "ifconfig st<x> up address netmask ..."
* 6. strip_open_low gets called
*
* When the user runs "ifconfig st<x> down"
* 7. strip_close_low gets called
*
* When the user kills the slattach process
* 8. strip_close gets called
* 9. strip_close calls dev_close
* 10. if the device is still up, then dev_close calls strip_close_low
* 11. strip_close calls strip_free
*/
/* Open the low-level part of the STRIP channel. Easy! */
static int strip_open_low(struct device *dev)
{
struct strip *strip_info = (struct strip *)(dev->priv);
if (strip_info->tty == NULL)
return(-ENODEV);
if (!allocate_buffers(strip_info))
return(-ENOMEM);
strip_info->discard = 0;
strip_info->working = FALSE;
strip_info->structured_messages = FALSE;
strip_info->sx_count = 0;
strip_info->tx_left = 0;
/*
* Needed because address '0' is special
*/
if (dev->pa_addr == 0)
dev->pa_addr=ntohl(0xC0A80001);
dev->tbusy = 0;
dev->start = 1;
printk(KERN_INFO "%s: Initializing Radio.\n", strip_info->dev.name);
ResetRadio(strip_info);
strip_info->idle_timer.expires = jiffies + 2 * HZ;
add_timer(&strip_info->idle_timer);
return(0);
}
/*
* Close the low-level part of the STRIP channel. Easy!
*/
static int strip_close_low(struct device *dev)
{
struct strip *strip_info = (struct strip *)(dev->priv);
if (strip_info->tty == NULL)
return -EBUSY;
strip_info->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
dev->tbusy = 1;
dev->start = 0;
/*
* Free all STRIP frame buffers.
*/
if (strip_info->rx_buff)
{
kfree(strip_info->rx_buff);
strip_info->rx_buff = NULL;
}
if (strip_info->sx_buff)
{
kfree(strip_info->sx_buff);
strip_info->sx_buff = NULL;
}
if (strip_info->tx_buff)
{
kfree(strip_info->tx_buff);
strip_info->tx_buff = NULL;
}
del_timer(&strip_info->idle_timer);
return 0;
}
/*
* This routine is called by DDI when the
* (dynamically assigned) device is registered
*/
static int strip_dev_init(struct device *dev)
{
int i;
/*
* Finish setting up the DEVICE info.
*/
dev->trans_start = 0;
dev->last_rx = 0;
dev->tx_queue_len = 30; /* Drop after 30 frames queued */
dev->flags = 0;
dev->family = AF_INET;
dev->metric = 0;
dev->mtu = DEFAULT_STRIP_MTU;
dev->type = ARPHRD_METRICOM; /* dtang */
dev->hard_header_len = sizeof(STRIP_Header);
/*
* dev->priv Already holds a pointer to our struct strip
*/
*(MetricomAddress*)&dev->broadcast = broadcast_address;
dev->dev_addr[0] = 0;
dev->addr_len = sizeof(MetricomAddress);
dev->pa_addr = 0;
dev->pa_brdaddr = 0;
dev->pa_mask = 0;
dev->pa_alen = sizeof(unsigned long);
/*
* Pointer to the interface buffers.
*/
for (i = 0; i < DEV_NUMBUFFS; i++)
skb_queue_head_init(&dev->buffs[i]);
/*
* Pointers to interface service routines.
*/
dev->open = strip_open_low;
dev->stop = strip_close_low;
dev->hard_start_xmit = strip_xmit;
dev->hard_header = strip_header;
dev->rebuild_header = strip_rebuild_header;
/* dev->type_trans unused */
/* dev->set_multicast_list unused */
dev->set_mac_address = strip_set_dev_mac_address;
/* dev->do_ioctl unused */
/* dev->set_config unused */
dev->get_stats = strip_get_stats;
return 0;
}
/*
* Free a STRIP channel.
*/
static void strip_free(struct strip *strip_info)
{
MetricomNode *node, *free;
*(strip_info->referrer) = strip_info->next;
if (strip_info->next)
strip_info->next->referrer = strip_info->referrer;
strip_info->magic = 0;
for (node = strip_info->neighbor_list; node != NULL; )
{
free = node;
node = node->next;
kfree(free);
}
kfree(strip_info);
}
/*
* Allocate a new free STRIP channel
*/
static struct strip *strip_alloc(void)
{
int channel_id = 0;
struct strip **s = &struct_strip_list;
struct strip *strip_info = (struct strip *)
kmalloc(sizeof(struct strip), GFP_KERNEL);
if (!strip_info)
return(NULL); /* If no more memory, return */
/*
* Clear the allocated memory
*/
memset(strip_info, 0, sizeof(struct strip));
/*
* Search the list to find where to put our new entry
* (and in the process decide what channel number it is
* going to be)
*/
while (*s && (*s)->dev.base_addr == channel_id)
{
channel_id++;
s = &(*s)->next;
}
/*
* Fill in the link pointers
*/
strip_info->next = *s;
if (*s)
(*s)->referrer = &strip_info->next;
strip_info->referrer = s;
*s = strip_info;
strip_info->magic = STRIP_MAGIC;
strip_info->tty = NULL;
strip_info->gratuitous_arp = jiffies + LongTime;
strip_info->arp_interval = 0;
init_timer(&strip_info->idle_timer);
strip_info->idle_timer.data = (long)&strip_info->dev;
strip_info->idle_timer.function = strip_IdleTask;
strip_info->neighbor_list = kmalloc(sizeof(MetricomNode), GFP_KERNEL);
strip_info->neighbor_list->type = 0;
strip_info->neighbor_list->next = NULL;
/* Note: strip_info->if_name is currently 8 characters long */
sprintf(strip_info->if_name, "st%d", channel_id);
strip_info->dev.name = strip_info->if_name;
strip_info->dev.base_addr = channel_id;
strip_info->dev.priv = (void*)strip_info;
strip_info->dev.next = NULL;
strip_info->dev.init = strip_dev_init;
return(strip_info);
}
/*
* Open the high-level part of the STRIP channel.
* This function is called by the TTY module when the
* STRIP line discipline is called for. Because we are
* sure the tty line exists, we only have to link it to
* a free STRIP channel...
*/
static int strip_open(struct tty_struct *tty)
{
struct strip *strip_info = (struct strip *) tty->disc_data;
/*
* First make sure we're not already connected.
*/
if (strip_info && strip_info->magic == STRIP_MAGIC)
return -EEXIST;
/*
* OK. Find a free STRIP channel to use.
*/
if ((strip_info = strip_alloc()) == NULL)
return -ENFILE;
/*
* Register our newly created device so it can be ifconfig'd
* strip_dev_init() will be called as a side-effect
*/
if (register_netdev(&strip_info->dev) != 0)
{
printk(KERN_ERR "strip: register_netdev() failed.\n");
strip_free(strip_info);
return -ENFILE;
}
strip_info->tty = tty;
tty->disc_data = strip_info;
if (tty->driver.flush_buffer)
tty->driver.flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
/*
* Restore default settings
*/
strip_info->dev.type = ARPHRD_METRICOM; /* dtang */
/*
* Set tty options
*/
tty->termios->c_iflag |= IGNBRK |IGNPAR;/* Ignore breaks and parity errors. */
tty->termios->c_cflag |= CLOCAL; /* Ignore modem control signals. */
tty->termios->c_cflag &= ~HUPCL; /* Don't close on hup */
#ifdef MODULE
MOD_INC_USE_COUNT;
#endif
/*
* Done. We have linked the TTY line to a channel.
*/
return(strip_info->dev.base_addr);
}
/*
* Close down a STRIP channel.
* This means flushing out any pending queues, and then restoring the
* TTY line discipline to what it was before it got hooked to STRIP
* (which usually is TTY again).
*/
static void strip_close(struct tty_struct *tty)
{
struct strip *strip_info = (struct strip *) tty->disc_data;
/*
* First make sure we're connected.
*/
if (!strip_info || strip_info->magic != STRIP_MAGIC)
return;
dev_close(&strip_info->dev);
unregister_netdev(&strip_info->dev);
tty->disc_data = 0;
strip_info->tty = NULL;
strip_free(strip_info);
tty->disc_data = NULL;
#ifdef MODULE
MOD_DEC_USE_COUNT;
#endif
}
/************************************************************************/
/* Perform I/O control calls on an active STRIP channel. */
static int strip_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct strip *strip_info = (struct strip *) tty->disc_data;
int err;
/*
* First make sure we're connected.
*/
if (!strip_info || strip_info->magic != STRIP_MAGIC)
return -EINVAL;
switch(cmd)
{
case SIOCGIFNAME:
err = verify_area(VERIFY_WRITE, (void*)arg, 16);
if (err)
return -err;
memcpy_tofs((void*)arg, strip_info->dev.name,
strlen(strip_info->dev.name) + 1);
return 0;
case SIOCSIFHWADDR:
return -EINVAL;
/*
* Allow stty to read, but not set, the serial port
*/
case TCGETS:
case TCGETA:
return n_tty_ioctl(tty, (struct file *) file, cmd,
(unsigned long) arg);
default:
return -ENOIOCTLCMD;
}
}
/************************************************************************/
/* Initialization */
/*
* Registers with the /proc file system to create different /proc/net files.
*/
static int strip_proc_net_register(unsigned short type, char *file_name,
int (*get_info)(char *, char **, off_t, int, int))
{
struct proc_dir_entry *strip_entry;
strip_entry = kmalloc(sizeof(struct proc_dir_entry), GFP_ATOMIC);
memset(strip_entry, 0, sizeof(struct proc_dir_entry));
strip_entry->low_ino = type;
strip_entry->namelen = strlen(file_name);
strip_entry->name = file_name;
strip_entry->mode = S_IFREG | S_IRUGO;
strip_entry->nlink = 1;
strip_entry->uid = 0;
strip_entry->gid = 0;
strip_entry->size = 0;
strip_entry->ops = &proc_net_inode_operations;
strip_entry->get_info = get_info;
return proc_net_register(strip_entry);
}
/*
* Initialize the STRIP driver.
* This routine is called at boot time, to bootstrap the multi-channel
* STRIP driver
*/
#ifdef MODULE
static
#endif
int strip_init_ctrl_dev(struct device *dummy)
{
static struct tty_ldisc strip_ldisc;
int status;
printk("STRIP: version %s (unlimited channels)\n", StripVersion);
/*
* Fill in our line protocol discipline, and register it
*/
memset(&strip_ldisc, 0, sizeof(strip_ldisc));
strip_ldisc.magic = TTY_LDISC_MAGIC;
strip_ldisc.flags = 0;
strip_ldisc.open = strip_open;
strip_ldisc.close = strip_close;
strip_ldisc.read = NULL;
strip_ldisc.write = NULL;
strip_ldisc.ioctl = strip_ioctl;
strip_ldisc.select = NULL;
strip_ldisc.receive_buf = strip_receive_buf;
strip_ldisc.receive_room = strip_receive_room;
strip_ldisc.write_wakeup = strip_write_some_more;
status = tty_register_ldisc(N_STRIP, &strip_ldisc);
if (status != 0)
{
printk(KERN_ERR "STRIP: can't register line discipline (err = %d)\n", status);
}
/*
* Register the status and trace files with /proc
*/
#if DO_PROC_NET_STRIP_STATUS
if (strip_proc_net_register(PROC_NET_STRIP_STATUS, "strip_status",
&strip_get_status_info) != 0)
{
printk(KERN_ERR "strip: status strip_proc_net_register() failed.\n");
}
#endif
#if DO_PROC_NET_STRIP_TRACE
if (strip_proc_net_register(PROC_NET_STRIP_TRACE, "strip_trace",
&strip_get_trace_info) != 0)
{
printk(KERN_ERR "strip: trace strip_proc_net_register() failed.\n");
}
#endif
#ifdef MODULE
return status;
#else
/* Return "not found", so that dev_init() will unlink
* the placeholder device entry for us.
*/
return ENODEV;
#endif
}
/************************************************************************/
/* From here down is only used when compiled as an external module */
#ifdef MODULE
int init_module(void)
{
return strip_init_ctrl_dev(0);
}
void cleanup_module(void)
{
int i;
while (struct_strip_list)
strip_free(struct_strip_list);
/* Unregister with the /proc/net files here. */
#if DO_PROC_NET_STRIP_TRACE
proc_net_unregister(PROC_NET_STRIP_TRACE);
#endif
#if DO_PROC_NET_STRIP_STATUS
proc_net_unregister(PROC_NET_STRIP_STATUS);
#endif
if ((i = tty_register_ldisc(N_STRIP, NULL)))
printk(KERN_ERR "STRIP: can't unregister line discipline (err = %d)\n", i);
}
#endif /* MODULE */
