1/*
2 *	Sealevel Systems 4021 driver.
3 *
4 *	This program is free software; you can redistribute it and/or
5 *	modify it under the terms of the GNU General Public License
6 *	as published by the Free Software Foundation; either version
7 *	2 of the License, or (at your option) any later version.
8 *
9 *	(c) Copyright 1999, 2001 Alan Cox
10 *	(c) Copyright 2001 Red Hat Inc.
11 *
12 */
13
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/mm.h>
17#include <linux/net.h>
18#include <linux/skbuff.h>
19#include <linux/netdevice.h>
20#include <linux/if_arp.h>
21#include <linux/delay.h>
22#include <linux/ioport.h>
23#include <net/arp.h>
24
25#include <asm/io.h>
26#include <asm/dma.h>
27#include <asm/byteorder.h>
28#include <net/syncppp.h>
29#include "z85230.h"
30
31
32struct slvl_device
33{
34	void *if_ptr;	/* General purpose pointer (used by SPPP) */
35	struct z8530_channel *chan;
36	struct ppp_device netdev;
37	int channel;
38};
39
40
41struct slvl_board
42{
43	struct slvl_device dev[2];
44	struct z8530_dev board;
45	int iobase;
46};
47
48/*
49 *	Network driver support routines
50 */
51
52/*
53 *	Frame receive. Simple for our card as we do sync ppp and there
54 *	is no funny garbage involved
55 */
56
57static void sealevel_input(struct z8530_channel *c, struct sk_buff *skb)
58{
59	/* Drop the CRC - its not a good idea to try and negotiate it ;) */
60	skb_trim(skb, skb->len-2);
61	skb->protocol=htons(ETH_P_WAN_PPP);
62	skb->mac.raw=skb->data;
63	skb->dev=c->netdevice;
64	/*
65	 *	Send it to the PPP layer. We dont have time to process
66	 *	it right now.
67	 */
68	netif_rx(skb);
69	c->netdevice->last_rx = jiffies;
70}
71
72/*
73 *	We've been placed in the UP state
74 */
75
76static int sealevel_open(struct net_device *d)
77{
78	struct slvl_device *slvl=d->priv;
79	int err = -1;
80	int unit = slvl->channel;
81
82	/*
83	 *	Link layer up.
84	 */
85
86	switch(unit)
87	{
88		case 0:
89			err=z8530_sync_dma_open(d, slvl->chan);
90			break;
91		case 1:
92			err=z8530_sync_open(d, slvl->chan);
93			break;
94	}
95
96	if(err)
97		return err;
98	/*
99	 *	Begin PPP
100	 */
101	err=sppp_open(d);
102	if(err)
103	{
104		switch(unit)
105		{
106			case 0:
107				z8530_sync_dma_close(d, slvl->chan);
108				break;
109			case 1:
110				z8530_sync_close(d, slvl->chan);
111				break;
112		}
113		return err;
114	}
115
116	slvl->chan->rx_function=sealevel_input;
117
118	/*
119	 *	Go go go
120	 */
121	netif_start_queue(d);
122	MOD_INC_USE_COUNT;
123	return 0;
124}
125
126static int sealevel_close(struct net_device *d)
127{
128	struct slvl_device *slvl=d->priv;
129	int unit = slvl->channel;
130
131	/*
132	 *	Discard new frames
133	 */
134
135	slvl->chan->rx_function=z8530_null_rx;
136
137	/*
138	 *	PPP off
139	 */
140	sppp_close(d);
141	/*
142	 *	Link layer down
143	 */
144
145	netif_stop_queue(d);
146
147	switch(unit)
148	{
149		case 0:
150			z8530_sync_dma_close(d, slvl->chan);
151			break;
152		case 1:
153			z8530_sync_close(d, slvl->chan);
154			break;
155	}
156	MOD_DEC_USE_COUNT;
157	return 0;
158}
159
160static int sealevel_ioctl(struct net_device *d, struct ifreq *ifr, int cmd)
161{
162	/* struct slvl_device *slvl=d->priv;
163	   z8530_ioctl(d,&slvl->sync.chanA,ifr,cmd) */
164	return sppp_do_ioctl(d, ifr,cmd);
165}
166
167static struct net_device_stats *sealevel_get_stats(struct net_device *d)
168{
169	struct slvl_device *slvl=d->priv;
170	if(slvl)
171		return z8530_get_stats(slvl->chan);
172	else
173		return NULL;
174}
175
176/*
177 *	Passed PPP frames, fire them downwind.
178 */
179
180static int sealevel_queue_xmit(struct sk_buff *skb, struct net_device *d)
181{
182	struct slvl_device *slvl=d->priv;
183	return z8530_queue_xmit(slvl->chan, skb);
184}
185
186static int sealevel_neigh_setup(struct neighbour *n)
187{
188	if (n->nud_state == NUD_NONE) {
189		n->ops = &arp_broken_ops;
190		n->output = n->ops->output;
191	}
192	return 0;
193}
194
195static int sealevel_neigh_setup_dev(struct net_device *dev, struct neigh_parms *p)
196{
197	if (p->tbl->family == AF_INET) {
198		p->neigh_setup = sealevel_neigh_setup;
199		p->ucast_probes = 0;
200		p->mcast_probes = 0;
201	}
202	return 0;
203}
204
205/*
206 *	Description block for a Comtrol Hostess SV11 card
207 */
208
209static struct slvl_board *slvl_init(int iobase, int irq, int txdma, int rxdma, int slow)
210{
211	struct z8530_dev *dev;
212	struct slvl_device *sv;
213	struct slvl_board *b;
214
215	unsigned long flags;
216	int u;
217
218	/*
219	 *	Get the needed I/O space
220	 */
221
222	if(!request_region(iobase, 8, "Sealevel 4021"))
223	{
224		printk(KERN_WARNING "sealevel: I/O 0x%X already in use.\n", iobase);
225		return NULL;
226	}
227
228	b=(struct slvl_board *)kmalloc(sizeof(struct slvl_board), GFP_KERNEL);
229	if(!b)
230		goto fail3;
231
232	memset(b, 0, sizeof(*sv));
233
234	b->dev[0].chan = &b->board.chanA;
235	b->dev[0].if_ptr = &b->dev[0].netdev;
236	b->dev[0].netdev.dev=(struct net_device *)
237		kmalloc(sizeof(struct net_device), GFP_KERNEL);
238	if(!b->dev[0].netdev.dev)
239		goto fail2;
240
241	b->dev[1].chan = &b->board.chanB;
242	b->dev[1].if_ptr = &b->dev[1].netdev;
243	b->dev[1].netdev.dev=(struct net_device *)
244		kmalloc(sizeof(struct net_device), GFP_KERNEL);
245	if(!b->dev[1].netdev.dev)
246		goto fail1_0;
247
248	dev=&b->board;
249
250	/*
251	 *	Stuff in the I/O addressing
252	 */
253
254	dev->active = 0;
255
256	b->iobase = iobase;
257
258	/*
259	 *	Select 8530 delays for the old board
260	 */
261
262	if(slow)
263		iobase |= Z8530_PORT_SLEEP;
264
265	dev->chanA.ctrlio=iobase+1;
266	dev->chanA.dataio=iobase;
267	dev->chanB.ctrlio=iobase+3;
268	dev->chanB.dataio=iobase+2;
269
270	dev->chanA.irqs=&z8530_nop;
271	dev->chanB.irqs=&z8530_nop;
272
273	/*
274	 *	Assert DTR enable DMA
275	 */
276
277	outb(3|(1<<7), b->iobase+4);
278
279
280	/* We want a fast IRQ for this device. Actually we'd like an even faster
281	   IRQ ;) - This is one driver RtLinux is made for */
282
283	if(request_irq(irq, &z8530_interrupt, SA_INTERRUPT, "SeaLevel", dev)<0)
284	{
285		printk(KERN_WARNING "sealevel: IRQ %d already in use.\n", irq);
286		goto fail1_1;
287	}
288
289	dev->irq=irq;
290	dev->chanA.private=&b->dev[0];
291	dev->chanB.private=&b->dev[1];
292	dev->chanA.netdevice=b->dev[0].netdev.dev;
293	dev->chanB.netdevice=b->dev[1].netdev.dev;
294	dev->chanA.dev=dev;
295	dev->chanB.dev=dev;
296
297	dev->chanA.txdma=3;
298	dev->chanA.rxdma=1;
299	if(request_dma(dev->chanA.txdma, "SeaLevel (TX)")!=0)
300		goto fail;
301
302	if(request_dma(dev->chanA.rxdma, "SeaLevel (RX)")!=0)
303		goto dmafail;
304
305	save_flags(flags);
306	cli();
307
308	/*
309	 *	Begin normal initialise
310	 */
311
312	if(z8530_init(dev)!=0)
313	{
314		printk(KERN_ERR "Z8530 series device not found.\n");
315		restore_flags(flags);
316		goto dmafail2;
317	}
318	if(dev->type==Z85C30)
319	{
320		z8530_channel_load(&dev->chanA, z8530_hdlc_kilostream);
321		z8530_channel_load(&dev->chanB, z8530_hdlc_kilostream);
322	}
323	else
324	{
325		z8530_channel_load(&dev->chanA, z8530_hdlc_kilostream_85230);
326		z8530_channel_load(&dev->chanB, z8530_hdlc_kilostream_85230);
327	}
328
329	/*
330	 *	Now we can take the IRQ
331	 */
332
333	restore_flags(flags);
334
335	for(u=0; u<2; u++)
336	{
337		sv=&b->dev[u];
338		sv->channel = u;
339
340		if(dev_alloc_name(sv->chan->netdevice,"hdlc%d")>=0)
341		{
342			struct net_device *d=sv->chan->netdevice;
343
344			/*
345			 *	Initialise the PPP components
346			 */
347			sppp_attach(&sv->netdev);
348
349			/*
350			 *	Local fields
351			 */
352
353			d->base_addr = iobase;
354			d->irq = irq;
355			d->priv = sv;
356			d->init = NULL;
357
358			d->open = sealevel_open;
359			d->stop = sealevel_close;
360			d->hard_start_xmit = sealevel_queue_xmit;
361			d->get_stats = sealevel_get_stats;
362			d->set_multicast_list = NULL;
363			d->do_ioctl = sealevel_ioctl;
364			d->neigh_setup = sealevel_neigh_setup_dev;
365			d->set_mac_address = NULL;
366
367			if(register_netdev(d)==-1)
368			{
369				printk(KERN_ERR "%s: unable to register device.\n",
370					d->name);
371				goto fail_unit;
372			}
373
374			break;
375		}
376	}
377	z8530_describe(dev, "I/O", iobase);
378	dev->active=1;
379	return b;
380
381fail_unit:
382	if(u==1)
383		unregister_netdev(b->dev[0].chan->netdevice);
384
385dmafail2:
386	free_dma(dev->chanA.rxdma);
387dmafail:
388	free_dma(dev->chanA.txdma);
389fail:
390	free_irq(irq, dev);
391fail1_1:
392	kfree(b->dev[1].netdev.dev);
393fail1_0:
394	kfree(b->dev[0].netdev.dev);
395fail2:
396	kfree(b);
397fail3:
398	release_region(iobase,8);
399	return NULL;
400}
401
402static void slvl_shutdown(struct slvl_board *b)
403{
404	int u;
405
406	z8530_shutdown(&b->board);
407
408	for(u=0; u<2; u++)
409	{
410		sppp_detach(b->dev[u].netdev.dev);
411		unregister_netdev(b->dev[u].netdev.dev);
412	}
413
414	free_irq(b->board.irq, &b->board);
415	free_dma(b->board.chanA.rxdma);
416	free_dma(b->board.chanA.txdma);
417	/* DMA off on the card, drop DTR */
418	outb(0, b->iobase);
419	release_region(b->iobase, 8);
420}
421
422#ifdef MODULE
423
424static int io=0x238;
425static int txdma=1;
426static int rxdma=3;
427static int irq=5;
428static int slow=0;
429
430MODULE_PARM(io,"i");
431MODULE_PARM_DESC(io, "The I/O base of the Sealevel card");
432MODULE_PARM(txdma,"i");
433MODULE_PARM_DESC(txdma, "Transmit DMA channel");
434MODULE_PARM(rxdma,"i");
435MODULE_PARM_DESC(rxdma, "Receive DMA channel");
436MODULE_PARM(irq,"i");
437MODULE_PARM_DESC(irq, "The interrupt line setting for the SeaLevel card");
438MODULE_PARM(slow,"i");
439MODULE_PARM_DESC(slow, "Set this for an older Sealevel card such as the 4012");
440
441MODULE_AUTHOR("Alan Cox");
442MODULE_LICENSE("GPL");
443MODULE_DESCRIPTION("Modular driver for the SeaLevel 4021");
444
445static struct slvl_board *slvl_unit;
446
447int init_module(void)
448{
449	printk(KERN_INFO "SeaLevel Z85230 Synchronous Driver v 0.01.\n");
450	printk(KERN_INFO "(c) Copyright 1998, Building Number Three Ltd.\n");
451	if((slvl_unit=slvl_init(io,irq, txdma, rxdma, slow))==NULL)
452		return -ENODEV;
453	return 0;
454}
455
456void cleanup_module(void)
457{
458	if(slvl_unit)
459		slvl_shutdown(slvl_unit);
460}
461
462#endif
463
464