1 /* 2 * Copyright (c) 1997-2000 LAN Media Corporation (LMC) 3 * All rights reserved. www.lanmedia.com 4 * 5 * This code is written by: 6 * Andrew Stanley-Jones (asj@cban.com) 7 * Rob Braun (bbraun@vix.com), 8 * Michael Graff (explorer@vix.com) and 9 * Matt Thomas (matt@3am-software.com). 10 * 11 * With Help By: 12 * David Boggs 13 * Ron Crane 14 * Allan Cox 15 * 16 * This software may be used and distributed according to the terms 17 * of the GNU General Public License version 2, incorporated herein by reference. 18 * 19 * Driver for the LanMedia LMC5200, LMC5245, LMC1000, LMC1200 cards. 20 */ 21 22#include <linux/kernel.h> 23#include <linux/string.h> 24#include <linux/timer.h> 25#include <linux/ptrace.h> 26#include <linux/errno.h> 27#include <linux/ioport.h> 28#include <linux/slab.h> 29#include <linux/interrupt.h> 30#include <linux/in.h> 31#include <linux/if_arp.h> 32#include <linux/netdevice.h> 33#include <linux/etherdevice.h> 34#include <linux/skbuff.h> 35#include <linux/inet.h> 36#include <linux/workqueue.h> 37#include <linux/proc_fs.h> 38#include <linux/bitops.h> 39 40#include <net/syncppp.h> 41 42#include <asm/processor.h> /* Processor type for cache alignment. */ 43#include <asm/io.h> 44#include <asm/dma.h> 45#include <linux/smp.h> 46 47#include "lmc.h" 48#include "lmc_var.h" 49#include "lmc_debug.h" 50#include "lmc_ioctl.h" 51#include "lmc_proto.h" 52 53/* 54 * The compile-time variable SPPPSTUP causes the module to be 55 * compiled without referencing any of the sync ppp routines. 56 */ 57#ifdef SPPPSTUB 58#define SPPP_detach(d) (void)0 59#define SPPP_open(d) 0 60#define SPPP_reopen(d) (void)0 61#define SPPP_close(d) (void)0 62#define SPPP_attach(d) (void)0 63#define SPPP_do_ioctl(d,i,c) -EOPNOTSUPP 64#else 65#define SPPP_attach(x) sppp_attach((x)->pd) 66#define SPPP_detach(x) sppp_detach((x)->pd->dev) 67#define SPPP_open(x) sppp_open((x)->pd->dev) 68#define SPPP_reopen(x) sppp_reopen((x)->pd->dev) 69#define SPPP_close(x) sppp_close((x)->pd->dev) 70#define SPPP_do_ioctl(x, y, z) sppp_do_ioctl((x)->pd->dev, (y), (z)) 71#endif 72 73// init 74void lmc_proto_init(lmc_softc_t *sc) /*FOLD00*/ 75{ 76 lmc_trace(sc->lmc_device, "lmc_proto_init in"); 77 switch(sc->if_type){ 78 case LMC_PPP: 79 sc->pd = kmalloc(sizeof(struct ppp_device), GFP_KERNEL); 80 if (!sc->pd) { 81 printk("lmc_proto_init(): kmalloc failure!\n"); 82 return; 83 } 84 sc->pd->dev = sc->lmc_device; 85 sc->if_ptr = sc->pd; 86 break; 87 case LMC_RAW: 88 break; 89 default: 90 break; 91 } 92 lmc_trace(sc->lmc_device, "lmc_proto_init out"); 93} 94 95// attach 96void lmc_proto_attach(lmc_softc_t *sc) /*FOLD00*/ 97{ 98 lmc_trace(sc->lmc_device, "lmc_proto_attach in"); 99 switch(sc->if_type){ 100 case LMC_PPP: 101 { 102 struct net_device *dev = sc->lmc_device; 103 SPPP_attach(sc); 104 dev->do_ioctl = lmc_ioctl; 105 } 106 break; 107 case LMC_NET: 108 { 109 struct net_device *dev = sc->lmc_device; 110 /* 111 * They set a few basics because they don't use sync_ppp 112 */ 113 dev->flags |= IFF_POINTOPOINT; 114 dev->hard_header = NULL; 115 dev->hard_header_len = 0; 116 dev->addr_len = 0; 117 } 118 case LMC_RAW: /* Setup the task queue, maybe we should notify someone? */ 119 { 120 } 121 default: 122 break; 123 } 124 lmc_trace(sc->lmc_device, "lmc_proto_attach out"); 125} 126 127// detach 128void lmc_proto_detach(lmc_softc_t *sc) /*FOLD00*/ 129{ 130 switch(sc->if_type){ 131 case LMC_PPP: 132 SPPP_detach(sc); 133 break; 134 case LMC_RAW: /* Tell someone we're detaching? */ 135 break; 136 default: 137 break; 138 } 139 140} 141 142// reopen 143void lmc_proto_reopen(lmc_softc_t *sc) /*FOLD00*/ 144{ 145 lmc_trace(sc->lmc_device, "lmc_proto_reopen in"); 146 switch(sc->if_type){ 147 case LMC_PPP: 148 SPPP_reopen(sc); 149 break; 150 case LMC_RAW: /* Reset the interface after being down, prerape to receive packets again */ 151 break; 152 default: 153 break; 154 } 155 lmc_trace(sc->lmc_device, "lmc_proto_reopen out"); 156} 157 158 159// ioctl 160int lmc_proto_ioctl(lmc_softc_t *sc, struct ifreq *ifr, int cmd) /*FOLD00*/ 161{ 162 lmc_trace(sc->lmc_device, "lmc_proto_ioctl out"); 163 switch(sc->if_type){ 164 case LMC_PPP: 165 return SPPP_do_ioctl (sc, ifr, cmd); 166 break; 167 default: 168 return -EOPNOTSUPP; 169 break; 170 } 171 lmc_trace(sc->lmc_device, "lmc_proto_ioctl out"); 172} 173 174// open 175void lmc_proto_open(lmc_softc_t *sc) /*FOLD00*/ 176{ 177 int ret; 178 179 lmc_trace(sc->lmc_device, "lmc_proto_open in"); 180 switch(sc->if_type){ 181 case LMC_PPP: 182 ret = SPPP_open(sc); 183 if(ret < 0) 184 printk("%s: syncPPP open failed: %d\n", sc->name, ret); 185 break; 186 case LMC_RAW: /* We're about to start getting packets! */ 187 break; 188 default: 189 break; 190 } 191 lmc_trace(sc->lmc_device, "lmc_proto_open out"); 192} 193 194// close 195 196void lmc_proto_close(lmc_softc_t *sc) /*FOLD00*/ 197{ 198 lmc_trace(sc->lmc_device, "lmc_proto_close in"); 199 switch(sc->if_type){ 200 case LMC_PPP: 201 SPPP_close(sc); 202 break; 203 case LMC_RAW: /* Interface going down */ 204 break; 205 default: 206 break; 207 } 208 lmc_trace(sc->lmc_device, "lmc_proto_close out"); 209} 210 211unsigned short lmc_proto_type(lmc_softc_t *sc, struct sk_buff *skb) /*FOLD00*/ 212{ 213 lmc_trace(sc->lmc_device, "lmc_proto_type in"); 214 switch(sc->if_type){ 215 case LMC_PPP: 216 return htons(ETH_P_WAN_PPP); 217 break; 218 case LMC_NET: 219 return htons(ETH_P_802_2); 220 break; 221 case LMC_RAW: /* Packet type for skbuff kind of useless */ 222 return htons(ETH_P_802_2); 223 break; 224 default: 225 printk(KERN_WARNING "%s: No protocol set for this interface, assuming 802.2 (which is wrong!!)\n", sc->name); 226 return htons(ETH_P_802_2); 227 break; 228 } 229 lmc_trace(sc->lmc_device, "lmc_proto_tye out"); 230 231} 232 233void lmc_proto_netif(lmc_softc_t *sc, struct sk_buff *skb) /*FOLD00*/ 234{ 235 lmc_trace(sc->lmc_device, "lmc_proto_netif in"); 236 switch(sc->if_type){ 237 case LMC_PPP: 238 case LMC_NET: 239 default: 240 skb->dev->last_rx = jiffies; 241 netif_rx(skb); 242 break; 243 case LMC_RAW: 244 break; 245 } 246 lmc_trace(sc->lmc_device, "lmc_proto_netif out"); 247} 248