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